raffel 0.1.2

package/dist/graphql/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GraphQL Module
+ *
+ * GraphQL adapter with automatic schema generation from Raffel handlers.
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from 'raffel'
+ *
+ * const server = createServer({
+ *   port: 3000,
+ *   graphql: {
+ *     path: '/graphql',
+ *     playground: true,
+ *   },
+ * })
+ *
+ * server
+ *   .procedure('users.list')
+ *   .input(z.object({ limit: z.number().optional() }))
+ *   .output(z.array(z.object({ id: z.string(), name: z.string() })))
+ *   .handler(async (input) => {
+ *     return db.users.findMany({ take: input.limit })
+ *   })
+ *
+ * await server.start()
+ * // GraphQL schema auto-generated:
+ * // Query { usersList(limit: Int): [UsersListOutput!]! }
+ * ```
+ */
+export { createGraphQLAdapter, createGraphQLMiddleware } from './adapter.js';
+export { generateGraphQLSchema, GraphQLJSON, GraphQLDateTime, type GenerateSchemaParams, } from './schema-generator.js';
+export type { GraphQLOptions, GraphQLAdapter, GraphQLAdapterOptions, SubscriptionOptions, SchemaGenerationOptions, GeneratedSchemaInfo, ZodToGraphQLOptions, SupportedZodType, CorsConfig as GraphQLCorsConfig, } from './types.js';
+export type { GraphQLMiddleware } from './adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/graphql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graphql/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAG5E,OAAO,EACL,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAA;AAG9B,YAAY,EACV,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,IAAI,iBAAiB,GAChC,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA"}

package/dist/graphql/index.js

@@ -0,0 +1,35 @@
+/**
+ * GraphQL Module
+ *
+ * GraphQL adapter with automatic schema generation from Raffel handlers.
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from 'raffel'
+ *
+ * const server = createServer({
+ *   port: 3000,
+ *   graphql: {
+ *     path: '/graphql',
+ *     playground: true,
+ *   },
+ * })
+ *
+ * server
+ *   .procedure('users.list')
+ *   .input(z.object({ limit: z.number().optional() }))
+ *   .output(z.array(z.object({ id: z.string(), name: z.string() })))
+ *   .handler(async (input) => {
+ *     return db.users.findMany({ take: input.limit })
+ *   })
+ *
+ * await server.start()
+ * // GraphQL schema auto-generated:
+ * // Query { usersList(limit: Int): [UsersListOutput!]! }
+ * ```
+ */
+// === Adapter ===
+export { createGraphQLAdapter, createGraphQLMiddleware } from './adapter.js';
+// === Schema Generator ===
+export { generateGraphQLSchema, GraphQLJSON, GraphQLDateTime, } from './schema-generator.js';
+//# sourceMappingURL=index.js.map

package/dist/graphql/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/graphql/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,kBAAkB;AAClB,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAE5E,2BAA2B;AAC3B,OAAO,EACL,qBAAqB,EACrB,WAAW,EACX,eAAe,GAEhB,MAAM,uBAAuB,CAAA"}

package/dist/graphql/schema-generator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GraphQL Schema Generator
+ *
+ * Auto-generates GraphQL schema from Raffel handlers and Zod schemas.
+ *
+ * Mapping:
+ * - Procedures → Query (read operations) or Mutation (write operations)
+ * - Streams → Subscription
+ * - Events → Mutation (fire-and-forget, if enabled)
+ */
+import { GraphQLScalarType } from 'graphql';
+import type { Registry } from '../core/registry.js';
+import type { SchemaRegistry } from '../validation/index.js';
+import type { SchemaGenerationOptions, GeneratedSchemaInfo } from './types.js';
+export declare const GraphQLJSON: GraphQLScalarType<any, unknown>;
+export declare const GraphQLDateTime: GraphQLScalarType<unknown, unknown>;
+export interface GenerateSchemaParams {
+    registry: Registry;
+    schemaRegistry: SchemaRegistry;
+    options?: SchemaGenerationOptions;
+}
+export declare function generateGraphQLSchema(params: GenerateSchemaParams): GeneratedSchemaInfo;
+//# sourceMappingURL=schema-generator.d.ts.map

package/dist/graphql/schema-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../src/graphql/schema-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAWL,iBAAiB,EAOlB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,wBAAwB,CAAA;AAE3E,OAAO,KAAK,EACV,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,YAAY,CAAA;AAOnB,eAAO,MAAM,WAAW,iCAmBtB,CAAA;AAEF,eAAO,MAAM,eAAe,qCAe1B,CAAA;AAkUF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,QAAQ,CAAA;IAClB,cAAc,EAAE,cAAc,CAAA;IAC9B,OAAO,CAAC,EAAE,uBAAuB,CAAA;CAClC;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,oBAAoB,GAAG,mBAAmB,CAwKvF"}

package/dist/graphql/schema-generator.int.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GraphQL Schema Generator Tests
+ */
+export {};
+//# sourceMappingURL=schema-generator.int.test.d.ts.map

package/dist/graphql/schema-generator.int.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-generator.int.test.d.ts","sourceRoot":"","sources":["../../src/graphql/schema-generator.int.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/graphql/schema-generator.int.test.js

@@ -0,0 +1,51 @@
+/**
+ * GraphQL Schema Generator Tests
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { z } from 'zod';
+import { createRegistry } from '../core/registry.js';
+import { createSchemaRegistry } from '../validation/index.js';
+import { generateGraphQLSchema } from './schema-generator.js';
+describe('generateGraphQLSchema', () => {
+    let registry;
+    let schemaRegistry;
+    beforeEach(() => {
+        registry = createRegistry();
+        schemaRegistry = createSchemaRegistry();
+    });
+    it('should map procedures using meta when configured', () => {
+        registry.procedure('users.get', async () => ({ id: '1' }), {
+            graphql: { type: 'query' },
+        });
+        registry.procedure('users.create', async () => ({ id: '2' }), {
+            graphql: { type: 'mutation' },
+        });
+        schemaRegistry.register('users.get', {
+            output: z.object({ id: z.string() }),
+        });
+        schemaRegistry.register('users.create', {
+            output: z.object({ id: z.string() }),
+        });
+        const result = generateGraphQLSchema({
+            registry,
+            schemaRegistry,
+            options: { procedureMapping: 'meta' },
+        });
+        expect(result.queries).toContain('users.get');
+        expect(result.mutations).toContain('users.create');
+    });
+    it('should treat missing meta as mutations when using meta mapping', () => {
+        registry.procedure('users.list', async () => []);
+        schemaRegistry.register('users.list', {
+            output: z.array(z.string()),
+        });
+        const result = generateGraphQLSchema({
+            registry,
+            schemaRegistry,
+            options: { procedureMapping: 'meta' },
+        });
+        expect(result.queries).not.toContain('users.list');
+        expect(result.mutations).toContain('users.list');
+    });
+});
+//# sourceMappingURL=schema-generator.int.test.js.map

package/dist/graphql/schema-generator.int.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-generator.int.test.js","sourceRoot":"","sources":["../../src/graphql/schema-generator.int.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACrC,IAAI,QAA2C,CAAA;IAC/C,IAAI,cAAuD,CAAA;IAE3D,UAAU,CAAC,GAAG,EAAE;QACd,QAAQ,GAAG,cAAc,EAAE,CAAA;QAC3B,cAAc,GAAG,oBAAoB,EAAE,CAAA;IACzC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,QAAQ,CAAC,SAAS,CAAC,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE;YACzD,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;SAC3B,CAAC,CAAA;QACF,QAAQ,CAAC,SAAS,CAAC,cAAc,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE;YAC5D,OAAO,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;SAC9B,CAAC,CAAA;QAEF,cAAc,CAAC,QAAQ,CAAC,WAAW,EAAE;YACnC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;SACrC,CAAC,CAAA;QACF,cAAc,CAAC,QAAQ,CAAC,cAAc,EAAE;YACtC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;SACrC,CAAC,CAAA;QAEF,MAAM,MAAM,GAAG,qBAAqB,CAAC;YACnC,QAAQ;YACR,cAAc;YACd,OAAO,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE;SACtC,CAAC,CAAA;QAEF,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;QAC7C,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;IACpD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,gEAAgE,EAAE,GAAG,EAAE;QACxE,QAAQ,CAAC,SAAS,CAAC,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC,EAAE,CAAC,CAAA;QAChD,cAAc,CAAC,QAAQ,CAAC,YAAY,EAAE;YACpC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SAC5B,CAAC,CAAA;QAEF,MAAM,MAAM,GAAG,qBAAqB,CAAC;YACnC,QAAQ;YACR,cAAc;YACd,OAAO,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE;SACtC,CAAC,CAAA;QAEF,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;QAClD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;IAClD,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/graphql/schema-generator.js

@@ -0,0 +1,502 @@
+/**
+ * GraphQL Schema Generator
+ *
+ * Auto-generates GraphQL schema from Raffel handlers and Zod schemas.
+ *
+ * Mapping:
+ * - Procedures → Query (read operations) or Mutation (write operations)
+ * - Streams → Subscription
+ * - Events → Mutation (fire-and-forget, if enabled)
+ */
+import { GraphQLSchema, GraphQLObjectType, GraphQLInputObjectType, GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLList, GraphQLNonNull, GraphQLEnumType, GraphQLScalarType, GraphQLUnionType, Kind, } from 'graphql';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('graphql-schema');
+// === Custom Scalars ===
+export const GraphQLJSON = new GraphQLScalarType({
+    name: 'JSON',
+    description: 'Arbitrary JSON value',
+    serialize: (value) => value,
+    parseValue: (value) => value,
+    parseLiteral: (ast) => {
+        if (ast.kind === Kind.STRING) {
+            try {
+                return JSON.parse(ast.value);
+            }
+            catch {
+                return ast.value;
+            }
+        }
+        if (ast.kind === Kind.INT)
+            return parseInt(ast.value, 10);
+        if (ast.kind === Kind.FLOAT)
+            return parseFloat(ast.value);
+        if (ast.kind === Kind.BOOLEAN)
+            return ast.value;
+        if (ast.kind === Kind.NULL)
+            return null;
+        return undefined;
+    },
+});
+export const GraphQLDateTime = new GraphQLScalarType({
+    name: 'DateTime',
+    description: 'ISO-8601 date-time string',
+    serialize: (value) => {
+        if (value instanceof Date)
+            return value.toISOString();
+        return value;
+    },
+    parseValue: (value) => {
+        if (typeof value === 'string')
+            return new Date(value);
+        return value;
+    },
+    parseLiteral: (ast) => {
+        if (ast.kind === Kind.STRING)
+            return new Date(ast.value);
+        return undefined;
+    },
+});
+// === Default Options ===
+const DEFAULT_OPTIONS = {
+    procedureMapping: 'prefix',
+    queryPrefixes: ['get', 'list', 'find', 'search', 'fetch', 'load', 'read', 'check', 'is', 'has', 'count'],
+    includeEvents: false,
+    typeNameGenerator: defaultTypeNameGenerator,
+    fieldNameGenerator: defaultFieldNameGenerator,
+    queryDescription: 'Root query type - read operations',
+    mutationDescription: 'Root mutation type - write operations',
+    subscriptionDescription: 'Root subscription type - real-time streams',
+};
+// === Name Generators ===
+function defaultTypeNameGenerator(handlerName) {
+    // 'users.get' → 'UsersGet'
+    // 'users.getById' → 'UsersGetById'
+    return handlerName
+        .split(/[.\-_]/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function defaultFieldNameGenerator(handlerName) {
+    // 'users.get' → 'usersGet'
+    // 'users.get-by-id' → 'usersGetById'
+    const parts = handlerName.split(/[.\-_]/);
+    return parts
+        .map((part, i) => (i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+        .join('');
+}
+function getZodTypeName(schema) {
+    // Access internal Zod type name
+    const def = schema._def;
+    return def?.typeName ?? 'unknown';
+}
+function zodToGraphQLOutput(schema, name, cache, isRequired = true) {
+    const typeName = getZodTypeName(schema);
+    const def = schema._def;
+    let baseType;
+    switch (typeName) {
+        case 'ZodString':
+            baseType = GraphQLString;
+            break;
+        case 'ZodNumber':
+            // Check if integer
+            if (def.checks?.some((c) => c.kind === 'int')) {
+                baseType = GraphQLInt;
+            }
+            else {
+                baseType = GraphQLFloat;
+            }
+            break;
+        case 'ZodBoolean':
+            baseType = GraphQLBoolean;
+            break;
+        case 'ZodDate':
+            baseType = GraphQLDateTime;
+            break;
+        case 'ZodArray': {
+            const itemType = zodToGraphQLOutput(def.type, `${name}Item`, cache, true);
+            baseType = new GraphQLList(itemType);
+            break;
+        }
+        case 'ZodObject': {
+            const cacheKey = name;
+            if (cache.output.has(cacheKey)) {
+                baseType = cache.output.get(cacheKey);
+            }
+            else {
+                const shape = def.shape();
+                const fields = {};
+                for (const [key, value] of Object.entries(shape)) {
+                    const fieldSchema = value;
+                    const fieldType = zodToGraphQLOutput(fieldSchema, `${name}${key.charAt(0).toUpperCase() + key.slice(1)}`, cache, !isZodOptional(fieldSchema));
+                    fields[key] = {
+                        type: fieldType,
+                        description: fieldSchema._def?.description,
+                    };
+                }
+                baseType = new GraphQLObjectType({
+                    name,
+                    fields: () => fields,
+                    description: def.description,
+                });
+                cache.output.set(cacheKey, baseType);
+            }
+            break;
+        }
+        case 'ZodEnum': {
+            const values = def.values;
+            const enumValues = {};
+            for (const val of values) {
+                const enumKey = val.toUpperCase().replace(/[^A-Z0-9_]/g, '_');
+                enumValues[enumKey] = { value: val };
+            }
+            baseType = new GraphQLEnumType({
+                name: `${name}Enum`,
+                values: enumValues,
+            });
+            break;
+        }
+        case 'ZodLiteral': {
+            const literalValue = def.value;
+            if (typeof literalValue === 'string') {
+                baseType = GraphQLString;
+            }
+            else if (typeof literalValue === 'number') {
+                baseType = Number.isInteger(literalValue) ? GraphQLInt : GraphQLFloat;
+            }
+            else if (typeof literalValue === 'boolean') {
+                baseType = GraphQLBoolean;
+            }
+            else {
+                baseType = GraphQLJSON;
+            }
+            break;
+        }
+        case 'ZodOptional':
+        case 'ZodNullable':
+            return zodToGraphQLOutput(def.innerType, name, cache, false);
+        case 'ZodDefault':
+            return zodToGraphQLOutput(def.innerType, name, cache, false);
+        case 'ZodUnion': {
+            // For simple unions, try to use a GraphQL union
+            const options = def.options;
+            const allObjects = options.every((opt) => getZodTypeName(opt) === 'ZodObject');
+            if (allObjects && options.length > 1) {
+                const types = options.map((opt, i) => zodToGraphQLOutput(opt, `${name}Option${i}`, cache, true));
+                baseType = new GraphQLUnionType({
+                    name: `${name}Union`,
+                    types,
+                });
+            }
+            else {
+                // Fall back to JSON for complex unions
+                baseType = GraphQLJSON;
+            }
+            break;
+        }
+        case 'ZodRecord':
+        case 'ZodMap':
+        case 'ZodAny':
+        case 'ZodUnknown':
+            baseType = GraphQLJSON;
+            break;
+        case 'ZodVoid':
+        case 'ZodUndefined':
+        case 'ZodNull':
+            baseType = GraphQLBoolean; // Represents success
+            break;
+        default:
+            logger.warn({ typeName, name }, 'Unknown Zod type, falling back to JSON');
+            baseType = GraphQLJSON;
+    }
+    return isRequired ? new GraphQLNonNull(baseType) : baseType;
+}
+function zodToGraphQLInput(schema, name, cache, isRequired = true) {
+    const typeName = getZodTypeName(schema);
+    const def = schema._def;
+    let baseType;
+    switch (typeName) {
+        case 'ZodString':
+            baseType = GraphQLString;
+            break;
+        case 'ZodNumber':
+            if (def.checks?.some((c) => c.kind === 'int')) {
+                baseType = GraphQLInt;
+            }
+            else {
+                baseType = GraphQLFloat;
+            }
+            break;
+        case 'ZodBoolean':
+            baseType = GraphQLBoolean;
+            break;
+        case 'ZodDate':
+            baseType = GraphQLDateTime;
+            break;
+        case 'ZodArray': {
+            const itemType = zodToGraphQLInput(def.type, `${name}Item`, cache, true);
+            baseType = new GraphQLList(itemType);
+            break;
+        }
+        case 'ZodObject': {
+            const cacheKey = `${name}Input`;
+            if (cache.input.has(cacheKey)) {
+                baseType = cache.input.get(cacheKey);
+            }
+            else {
+                const shape = def.shape();
+                const fields = {};
+                for (const [key, value] of Object.entries(shape)) {
+                    const fieldSchema = value;
+                    const fieldType = zodToGraphQLInput(fieldSchema, `${name}${key.charAt(0).toUpperCase() + key.slice(1)}`, cache, !isZodOptional(fieldSchema));
+                    fields[key] = {
+                        type: fieldType,
+                        description: fieldSchema._def?.description,
+                    };
+                }
+                baseType = new GraphQLInputObjectType({
+                    name: cacheKey,
+                    fields: () => fields,
+                    description: def.description,
+                });
+                cache.input.set(cacheKey, baseType);
+            }
+            break;
+        }
+        case 'ZodEnum': {
+            const values = def.values;
+            const enumValues = {};
+            for (const val of values) {
+                const enumKey = val.toUpperCase().replace(/[^A-Z0-9_]/g, '_');
+                enumValues[enumKey] = { value: val };
+            }
+            baseType = new GraphQLEnumType({
+                name: `${name}Enum`,
+                values: enumValues,
+            });
+            break;
+        }
+        case 'ZodLiteral': {
+            const literalValue = def.value;
+            if (typeof literalValue === 'string') {
+                baseType = GraphQLString;
+            }
+            else if (typeof literalValue === 'number') {
+                baseType = Number.isInteger(literalValue) ? GraphQLInt : GraphQLFloat;
+            }
+            else if (typeof literalValue === 'boolean') {
+                baseType = GraphQLBoolean;
+            }
+            else {
+                baseType = GraphQLJSON;
+            }
+            break;
+        }
+        case 'ZodOptional':
+        case 'ZodNullable':
+            return zodToGraphQLInput(def.innerType, name, cache, false);
+        case 'ZodDefault':
+            return zodToGraphQLInput(def.innerType, name, cache, false);
+        case 'ZodUnion':
+        case 'ZodRecord':
+        case 'ZodMap':
+        case 'ZodAny':
+        case 'ZodUnknown':
+            baseType = GraphQLJSON;
+            break;
+        default:
+            baseType = GraphQLJSON;
+    }
+    return isRequired ? new GraphQLNonNull(baseType) : baseType;
+}
+function isZodOptional(schema) {
+    const typeName = getZodTypeName(schema);
+    return typeName === 'ZodOptional' || typeName === 'ZodNullable' || typeName === 'ZodDefault';
+}
+export function generateGraphQLSchema(params) {
+    const { registry, schemaRegistry, options: userOptions } = params;
+    const options = { ...DEFAULT_OPTIONS, ...userOptions };
+    const typeCache = {
+        output: new Map(),
+        input: new Map(),
+    };
+    const queries = {};
+    const mutations = {};
+    const subscriptions = {};
+    const queryNames = [];
+    const mutationNames = [];
+    const subscriptionNames = [];
+    const skipped = [];
+    // Process procedures → Query or Mutation
+    for (const meta of registry.listProcedures()) {
+        const schema = schemaRegistry.get(meta.name);
+        const isQuery = isProcedureQuery(meta, options);
+        const field = createFieldFromHandler(meta.name, schema, options, typeCache, 'procedure');
+        if (!field) {
+            skipped.push({ name: meta.name, reason: 'No schema defined' });
+            continue;
+        }
+        const fieldName = options.fieldNameGenerator(meta.name);
+        if (isQuery) {
+            queries[fieldName] = field;
+            queryNames.push(meta.name);
+        }
+        else {
+            mutations[fieldName] = field;
+            mutationNames.push(meta.name);
+        }
+    }
+    // Process streams → Subscription
+    for (const meta of registry.listStreams()) {
+        const schema = schemaRegistry.get(meta.name);
+        const field = createFieldFromHandler(meta.name, schema, options, typeCache, 'stream');
+        if (!field) {
+            skipped.push({ name: meta.name, reason: 'No schema defined' });
+            continue;
+        }
+        const fieldName = options.fieldNameGenerator(meta.name);
+        subscriptions[fieldName] = field;
+        subscriptionNames.push(meta.name);
+    }
+    // Process events → Mutation (if enabled)
+    if (options.includeEvents) {
+        for (const meta of registry.listEvents()) {
+            const schema = schemaRegistry.get(meta.name);
+            const field = createFieldFromHandler(meta.name, schema, options, typeCache, 'event');
+            if (!field) {
+                skipped.push({ name: meta.name, reason: 'No schema defined' });
+                continue;
+            }
+            const fieldName = options.fieldNameGenerator(meta.name);
+            mutations[fieldName] = field;
+            mutationNames.push(meta.name);
+        }
+    }
+    // Build schema
+    const queryType = Object.keys(queries).length > 0
+        ? new GraphQLObjectType({
+            name: 'Query',
+            description: options.queryDescription,
+            fields: () => queries,
+        })
+        : undefined;
+    const mutationType = Object.keys(mutations).length > 0
+        ? new GraphQLObjectType({
+            name: 'Mutation',
+            description: options.mutationDescription,
+            fields: () => mutations,
+        })
+        : undefined;
+    const subscriptionType = Object.keys(subscriptions).length > 0
+        ? new GraphQLObjectType({
+            name: 'Subscription',
+            description: options.subscriptionDescription,
+            fields: () => subscriptions,
+        })
+        : undefined;
+    // At least Query is required
+    if (!queryType) {
+        // Create a dummy query if none exists
+        const dummyQuery = new GraphQLObjectType({
+            name: 'Query',
+            fields: {
+                _health: {
+                    type: GraphQLBoolean,
+                    description: 'Health check',
+                    resolve: () => true,
+                },
+            },
+        });
+        return {
+            schema: new GraphQLSchema({
+                query: dummyQuery,
+                mutation: mutationType,
+                subscription: subscriptionType,
+            }),
+            queries: ['_health'],
+            mutations: mutationNames,
+            subscriptions: subscriptionNames,
+            skipped,
+        };
+    }
+    const schema = new GraphQLSchema({
+        query: queryType,
+        mutation: mutationType,
+        subscription: subscriptionType,
+    });
+    logger.info({
+        queries: queryNames.length,
+        mutations: mutationNames.length,
+        subscriptions: subscriptionNames.length,
+        skipped: skipped.length,
+    }, 'Generated GraphQL schema');
+    return {
+        schema,
+        queries: queryNames,
+        mutations: mutationNames,
+        subscriptions: subscriptionNames,
+        skipped,
+    };
+}
+function isProcedureQuery(meta, options) {
+    switch (options.procedureMapping) {
+        case 'all-queries':
+            return true;
+        case 'all-mutations':
+            return false;
+        case 'meta':
+            return meta.graphql?.type === 'query';
+        case 'prefix':
+        default: {
+            // Check if name starts with a query prefix
+            const nameLower = meta.name.toLowerCase();
+            const lastSegment = meta.name.split('.').pop()?.toLowerCase() ?? nameLower;
+            return options.queryPrefixes.some((prefix) => lastSegment.startsWith(prefix));
+        }
+    }
+}
+function createFieldFromHandler(handlerName, schema, options, cache, kind) {
+    const typeName = options.typeNameGenerator(handlerName);
+    // For output type
+    let outputType;
+    if (schema?.output) {
+        // Cast to ZodTypeAny - the function handles the internal details
+        outputType = zodToGraphQLOutput(schema.output, `${typeName}Output`, cache, true);
+    }
+    else if (kind === 'event') {
+        // Events return success boolean
+        outputType = new GraphQLNonNull(GraphQLBoolean);
+    }
+    else {
+        // Default to JSON for handlers without output schema
+        outputType = GraphQLJSON;
+    }
+    // For input args
+    const args = {};
+    if (schema?.input) {
+        const inputTypeName = getZodTypeName(schema.input);
+        if (inputTypeName === 'ZodObject') {
+            // Flatten object fields as args
+            const def = schema.input._def;
+            const shape = def.shape();
+            for (const [key, value] of Object.entries(shape)) {
+                const fieldSchema = value;
+                args[key] = {
+                    type: zodToGraphQLInput(fieldSchema, `${typeName}${key.charAt(0).toUpperCase() + key.slice(1)}`, cache, !isZodOptional(fieldSchema)),
+                    description: fieldSchema._def?.description,
+                };
+            }
+        }
+        else {
+            // Single input arg
+            args['input'] = {
+                type: zodToGraphQLInput(schema.input, `${typeName}Input`, cache, true),
+            };
+        }
+    }
+    return {
+        type: outputType,
+        args: Object.keys(args).length > 0 ? args : undefined,
+        description: `Handler: ${handlerName}`,
+    };
+}
+//# sourceMappingURL=schema-generator.js.map