@martel/calyx 1.7.0 → 1.9.0

package/src/graphql/graphql.module.ts

@@ -0,0 +1,316 @@
+import { CalyxContainer } from '../core/container.ts';
+import { Module } from '../core/decorators.ts';
+import {
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLInputObjectType,
+  GraphQLScalarType,
+  GraphQLInterfaceType,
+  GraphQLUnionType,
+  GraphQLString,
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLBoolean,
+  GraphQLList,
+  GraphQLNonNull,
+} from 'graphql';
+
+@Module({})
+export class GraphQLModule {
+  static buildSchema(container: CalyxContainer): GraphQLSchema | null {
+    const instances = container.getProviderAndControllerInstances();
+    const resolverInstances = instances.filter(
+      (inst) => inst && inst.constructor && Reflect.hasMetadata('calyx:resolver', inst.constructor)
+    );
+
+    if (resolverInstances.length === 0) {
+      return null;
+    }
+
+    const typeMap = new Map<any, any>();
+    const inputTypeMap = new Map<any, any>();
+
+    function buildFieldsConfig(typeClass: any, isInput: boolean): any {
+      const fieldsMetadata: { propertyKey: string; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:fields', typeClass) || [];
+
+      const fieldsConfig: any = {};
+      for (const field of fieldsMetadata) {
+        let returnTypeClass = field.typeFunc ? field.typeFunc(null) : undefined;
+        if (!returnTypeClass) {
+          returnTypeClass = Reflect.getMetadata('design:type', typeClass.prototype, field.propertyKey);
+        }
+        if (!returnTypeClass) {
+          returnTypeClass = String;
+        }
+
+        let gqlType = isInput ? getGraphQLInputType(returnTypeClass) : getGraphQLType(returnTypeClass);
+        if (Array.isArray(returnTypeClass)) {
+          gqlType = new GraphQLList(isInput ? getGraphQLInputType(returnTypeClass[0]) : getGraphQLType(returnTypeClass[0]));
+        }
+        if (!field.options?.nullable) {
+          gqlType = new GraphQLNonNull(gqlType);
+        }
+        fieldsConfig[field.propertyKey] = { type: gqlType };
+      }
+      return fieldsConfig;
+    }
+
+    function getGraphQLType(typeClass: any): any {
+      if (typeClass === String) return GraphQLString;
+      if (typeClass === Number) return GraphQLFloat;
+      if (typeClass === Boolean) return GraphQLBoolean;
+      if (typeMap.has(typeClass)) return typeMap.get(typeClass);
+
+      // Custom Scalar
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:scalar', typeClass)) {
+        const scalarMeta = Reflect.getMetadata('calyx:scalar', typeClass);
+        const inst = container.get(typeClass) || new typeClass();
+        const gqlScalar = new GraphQLScalarType({
+          name: scalarMeta.name,
+          description: Reflect.getMetadata('calyx:description', typeClass),
+          serialize: inst.serialize ? inst.serialize.bind(inst) : (val: any) => val,
+          parseValue: inst.parseValue ? inst.parseValue.bind(inst) : (val: any) => val,
+          parseLiteral: inst.parseLiteral ? inst.parseLiteral.bind(inst) : undefined,
+        });
+        typeMap.set(typeClass, gqlScalar);
+        return gqlScalar;
+      }
+
+      // Interface
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:interface_type', typeClass)) {
+        const gqlInterfaceType = new GraphQLInterfaceType({
+          name: typeClass.name,
+          description: Reflect.getMetadata('calyx:description', typeClass),
+          fields: () => buildFieldsConfig(typeClass, false),
+        });
+        typeMap.set(typeClass, gqlInterfaceType);
+        return gqlInterfaceType;
+      }
+
+      // Union
+      if (typeClass && (typeClass.__isUnion || (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:union_type', typeClass)))) {
+        const unionMeta = typeClass.__isUnion ? typeClass : Reflect.getMetadata('calyx:union_type', typeClass);
+        const gqlUnionType = new GraphQLUnionType({
+          name: unionMeta.name,
+          types: () => unionMeta.types().map((t: any) => getGraphQLType(t)),
+          resolveType: unionMeta.resolveType,
+        });
+        typeMap.set(typeClass, gqlUnionType);
+        return gqlUnionType;
+      }
+
+      // ObjectType
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:object_type', typeClass)) {
+        const gqlObjectType = new GraphQLObjectType({
+          name: typeClass.name,
+          fields: () => buildFieldsConfig(typeClass, false),
+        });
+
+        typeMap.set(typeClass, gqlObjectType);
+        return gqlObjectType;
+      }
+
+      return GraphQLString;
+    }
+
+    function getGraphQLInputType(typeClass: any): any {
+      if (typeClass === String) return GraphQLString;
+      if (typeClass === Number) return GraphQLFloat;
+      if (typeClass === Boolean) return GraphQLBoolean;
+      if (inputTypeMap.has(typeClass)) return inputTypeMap.get(typeClass);
+
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:input_type', typeClass)) {
+        const gqlInputObjectType = new GraphQLInputObjectType({
+          name: typeClass.name,
+          fields: () => buildFieldsConfig(typeClass, true),
+        });
+
+        inputTypeMap.set(typeClass, gqlInputObjectType);
+        return gqlInputObjectType;
+      }
+
+      return GraphQLString;
+    }
+
+    const queryFields: any = {};
+    const mutationFields: any = {};
+    const subscriptionFields: any = {};
+
+    for (const resolverInstance of resolverInstances) {
+      const resolverClass = resolverInstance.constructor;
+
+      // Compile helper for queries, mutations, subscriptions
+      const compileField = (fieldMeta: { propertyKey: string | symbol; typeFunc?: any; options?: any }, list: any) => {
+        const returnTypeClass = fieldMeta.typeFunc ? fieldMeta.typeFunc(null) : String;
+        let gqlType = getGraphQLType(returnTypeClass);
+        if (Array.isArray(returnTypeClass)) {
+          gqlType = new GraphQLList(getGraphQLType(returnTypeClass[0]));
+        }
+
+        const argsMetadata: { parameterIndex: number; name: string }[] =
+          Reflect.getMetadata('calyx:args', resolverInstance, fieldMeta.propertyKey) || [];
+        const argsConfig: any = {};
+
+        const paramTypes = Reflect.getMetadata('design:paramtypes', resolverInstance, fieldMeta.propertyKey) || [];
+        for (const arg of argsMetadata) {
+          const paramType = paramTypes[arg.parameterIndex] || String;
+          if (!arg.name && typeof paramType === 'function' && Reflect.hasMetadata('calyx:args_type', paramType)) {
+            const fieldsMetadata = Reflect.getMetadata('calyx:fields', paramType) || [];
+            for (const f of fieldsMetadata) {
+              let fType = f.typeFunc ? f.typeFunc(null) : undefined;
+              if (!fType) {
+                fType = Reflect.getMetadata('design:type', paramType.prototype, f.propertyKey) || String;
+              }
+              let gqlFType = getGraphQLInputType(fType);
+              if (Array.isArray(fType)) {
+                gqlFType = new GraphQLList(getGraphQLInputType(fType[0]));
+              }
+              if (!f.options?.nullable) {
+                gqlFType = new GraphQLNonNull(gqlFType);
+              }
+              argsConfig[f.propertyKey] = { type: gqlFType };
+            }
+          } else {
+            const argName = arg.name || 'args';
+            argsConfig[argName] = { type: getGraphQLInputType(paramType) };
+          }
+        }
+
+        const fieldName = fieldMeta.options?.name || String(fieldMeta.propertyKey);
+
+        const resolveFn = async (parent: any, args: any, context: any) => {
+          const params: any[] = [];
+          for (const arg of argsMetadata) {
+            const paramType = paramTypes[arg.parameterIndex] || String;
+            if (!arg.name && typeof paramType === 'function' && Reflect.hasMetadata('calyx:args_type', paramType)) {
+              const argInst = new paramType();
+              const fieldsMetadata = Reflect.getMetadata('calyx:fields', paramType) || [];
+              for (const f of fieldsMetadata) {
+                argInst[f.propertyKey] = args[f.propertyKey];
+              }
+              params[arg.parameterIndex] = argInst;
+            } else {
+              const argName = arg.name || 'args';
+              params[arg.parameterIndex] = args[argName];
+            }
+          }
+          const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldMeta.propertyKey) || [];
+          for (const idx of parentParams) {
+            params[idx] = parent;
+          }
+          return resolverInstance[fieldMeta.propertyKey](...params);
+        };
+
+        list[fieldName] = {
+          type: gqlType,
+          args: argsConfig,
+          resolve: resolveFn,
+        };
+
+        return { argsMetadata, paramTypes };
+      };
+
+      // Queries
+      const queries: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:queries', resolverClass) || [];
+      for (const query of queries) {
+        compileField(query, queryFields);
+      }
+
+      // Mutations
+      const mutations: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:mutations', resolverClass) || [];
+      for (const mutation of mutations) {
+        compileField(mutation, mutationFields);
+      }
+
+      // Subscriptions
+      const subscriptions: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:subscriptions', resolverClass) || [];
+      for (const sub of subscriptions) {
+        const { argsMetadata, paramTypes } = compileField(sub, subscriptionFields);
+        const subName = sub.options?.name || String(sub.propertyKey);
+        
+        // Wrap with standard GraphQL subscribe / resolve
+        const originalResolve = subscriptionFields[subName].resolve;
+        subscriptionFields[subName].subscribe = originalResolve;
+        subscriptionFields[subName].resolve = (payload: any) => {
+          if (sub.options?.resolve) {
+            return sub.options.resolve(payload);
+          }
+          return payload;
+        };
+      }
+
+      // Resolve fields mapping
+      const resolvedType = Reflect.getMetadata('calyx:resolver', resolverClass);
+      const fieldResolvers: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:resolve_fields', resolverClass) || [];
+
+      if (resolvedType && fieldResolvers.length > 0) {
+        const targetGqlType = getGraphQLType(resolvedType);
+        if (targetGqlType && typeof targetGqlType.getFields === 'function') {
+          const targetFields = targetGqlType.getFields();
+          for (const fieldRes of fieldResolvers) {
+            const fieldName = fieldRes.options?.name || String(fieldRes.propertyKey);
+            if (targetFields[fieldName]) {
+              targetFields[fieldName].resolve = async (parent: any, args: any, context: any) => {
+                const argsMetadata: { parameterIndex: number; name: string }[] =
+                  Reflect.getMetadata('calyx:args', resolverInstance, fieldRes.propertyKey) || [];
+                const params: any[] = [];
+                const paramTypes = Reflect.getMetadata('design:paramtypes', resolverInstance, fieldRes.propertyKey) || [];
+                for (const arg of argsMetadata) {
+                  const paramType = paramTypes[arg.parameterIndex] || String;
+                  if (!arg.name && typeof paramType === 'function' && Reflect.hasMetadata('calyx:args_type', paramType)) {
+                    const argInst = new paramType();
+                    const fieldsMetadata = Reflect.getMetadata('calyx:fields', paramType) || [];
+                    for (const f of fieldsMetadata) {
+                      argInst[f.propertyKey] = args[f.propertyKey];
+                    }
+                    params[arg.parameterIndex] = argInst;
+                  } else {
+                    const argName = arg.name || 'args';
+                    params[arg.parameterIndex] = args[argName];
+                  }
+                }
+                const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldRes.propertyKey) || [];
+                for (const idx of parentParams) {
+                  params[idx] = parent;
+                }
+                return resolverInstance[fieldRes.propertyKey](...params);
+              };
+            }
+          }
+        }
+      }
+    }
+
+    if (Object.keys(queryFields).length === 0) {
+      return null;
+    }
+
+    return new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: queryFields,
+      }),
+      ...(Object.keys(mutationFields).length > 0
+        ? {
+            mutation: new GraphQLObjectType({
+              name: 'Mutation',
+              fields: mutationFields,
+            }),
+          }
+        : {}),
+      ...(Object.keys(subscriptionFields).length > 0
+        ? {
+            subscription: new GraphQLObjectType({
+              name: 'Subscription',
+              fields: subscriptionFields,
+            }),
+          }
+        : {}),
+    });
+  }
+}

package/src/graphql/index.ts

@@ -0,0 +1,2 @@
+export * from './decorators.ts';
+export * from './graphql.module.ts';