skiff-graphql

overwrite: true
schema:
  - ../../supergraph.graphql
  - ./src/editorLocalState.graphql
  - ./src/skemailLocalState.graphql
generates:
  src/types.ts:
    plugins:
      - 'typescript'
    config:
      scalars:
        Date: 'Date'
        JSON: 'Record<any, any>'
        PublicKey: '{ key: string, signature?: string }'

# Generate types from schema
yarn graphql-codegen --config codegen.yml

# Build the library
yarn build

# Watch for schema changes
yarn watch

import { 
  User,
  Document,
  PermissionLevel,
  AttendeeStatus,
  EventReminder,
  SubscriptionPlan
} from 'skiff-graphql';

// Use generated types in your code
function updateUser(user: User) {
  // TypeScript knows all User fields
  console.log(user.username, user.publicKey);
}

// Enums are also generated
const permission: PermissionLevel = PermissionLevel.Editor;

import type { 
  PublicKey,
  PublicKeyWithSignature,
  SocketEvent 
} from 'skiff-graphql';

// PublicKey: { key: string, signature?: string }
const pubKey: PublicKey = {
  key: 'base64-encoded-key',
  signature: 'optional-signature'
};

// PublicKeyWithSignature: { key: string, signature: string }
const signedKey: PublicKeyWithSignature = {
  key: 'base64-encoded-key',
  signature: 'required-signature'
};

import { 
  NotFound,
  NotAuthorized,
  BadRequest,
  RateLimitError,
  DocumentDoesNotExist,
  UserDoesNotExist
} from 'skiff-graphql';

// Throw typed errors
throw new NotFound('User not found');
throw new NotAuthorized('Insufficient permissions');
throw new BadRequest('Invalid input');

// Error with extensions
throw new RateLimitError('Too many requests', {
  msBeforeNext: 5000,
  throttled: true
});

import { NotFound, NotAuthorized } from 'skiff-graphql';

// Assert condition is true
NotFound.assert(user !== null, 'User not found');
// Throws NotFound error if user is null

// Assert value exists
NotAuthorized.assertExists(permissions, 'No permissions found');
// Throws NotAuthorized if permissions is null/undefined

function getDocument(docID: string | null) {
  // Assert and narrow type
  NotFound.assertExists(docID, 'Document ID required');
  // TypeScript now knows docID is string (not null)
  return fetchDocument(docID);
}

import {
  DocumentDoesNotExist,
  DocumentContentConflict,
  DocumentTooLarge,
  DocumentHierarchyConflict,
  NeedNewSessionKey,
  InvalidSignature
} from 'skiff-graphql';

// Document-specific errors
throw new DocumentDoesNotExist('Document not found');
throw new DocumentTooLarge('Document exceeds size limit');

// Document conflicts
throw new DocumentContentConflict('Content has been modified');
throw new DocumentHierarchyConflict('Invalid document hierarchy');

// Encryption errors with context
throw new NeedNewSessionKey('Session key rotation required', {
  docID: 'doc-123'
});

throw new InvalidSignature('Signature verification failed');

import {
  AuthenticationError,
  NotAuthorized,
  UserDoesNotExist
} from 'skiff-graphql';

throw new AuthenticationError('Invalid credentials');
throw new NotAuthorized('Editor permission required');
throw new UserDoesNotExist('User account not found');

import { RateLimitError } from 'skiff-graphql';

// Rate limit with retry information
throw new RateLimitError('Rate limit exceeded', {
  msBeforeNext: 30000,  // Wait 30 seconds
  throttled: true
});

// Handle rate limit errors
try {
  await apiCall();
} catch (error) {
  if (error.extensions?.code === RateLimitError.CODE) {
    const waitTime = error.extensions.msBeforeNext;
    console.log(`Retry after ${waitTime}ms`);
  }
}

import { NotFound, BadRequest } from 'skiff-graphql';

// Access error codes
NotFound.CODE;      // 'NOT_FOUND'
BadRequest.CODE;    // 'BAD_REQUEST'

// Use in error handling
if (error.extensions?.code === NotFound.CODE) {
  // Handle not found error
}

import { 
  isPaidTier,
  isFreeTier,
  getStorageLimitForTier 
} from 'skiff-graphql';

// Check subscription tier
if (isPaidTier(user.subscriptionPlan)) {
  // Enable premium features
}

// Get storage limits
const limit = getStorageLimitForTier(user.subscriptionPlan);

import { isApolloError, getErrorCode } from 'skiff-graphql';

// Check if error is Apollo error
if (isApolloError(error)) {
  const code = getErrorCode(error);
  console.log('Error code:', code);
}

# libs/skiff-graphql/src/editorLocalState.graphql
extend type Query {
  currentDocument: Document
  editorSettings: EditorSettings
}

# libs/skiff-graphql/src/skemailLocalState.graphql
extend type Query {
  currentThread: Thread
  mailFilters: [MailFilter]
}

import schema from 'skiff-graphql/src/completeSchema.graphql';

import { 
  User,
  Document,
  PermissionLevel,
  NotFound,
  NotAuthorized 
} from 'skiff-graphql';

interface ShareDocumentInput {
  docID: string;
  userEmail: string;
  permission: PermissionLevel;
}

async function shareDocument(
  input: ShareDocumentInput,
  currentUser: User
): Promise<Document> {
  // Use assertion for validation
  NotFound.assertExists(
    input.docID,
    'Document ID is required'
  );

  const doc = await fetchDocument(input.docID);
  
  NotFound.assertExists(
    doc,
    `Document ${input.docID} not found`
  );

  // Check permissions
  NotAuthorized.assert(
    doc.ownerID === currentUser.userID,
    'Only document owner can share'
  );

  // Share document with specified permission
  return await addDocumentPermission(
    doc,
    input.userEmail,
    input.permission
  );
}

{
  "dependencies": {
    "skiff-graphql": "workspace:libs/skiff-graphql"
  }
}