@orion-js/graphql 4.0.10 → 4.0.12

package/dist/index.cjs

@@ -648,54 +648,70 @@ function getStaticFields(schema) {
 }
 
 // src/buildSchema/getArgs/getField.ts
-Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
-var storedModelInput = {};
-var getCachedModelInput = (model, fields) => {
-  if (!storedModelInput[model.name]) {
-    storedModelInput[model.name] = new import_graphql4.GraphQLInputObjectType({
-      name: `${model.name}Input`,
-      fields
-    });
-  }
-  return storedModelInput[model.name];
-};
-var resolveModelFields = (model) => {
-  const fields = {};
-  for (const field of getStaticFields(model)) {
-    fields[field.key] = { type: resolveType(field.type) };
-  }
-  return fields;
-};
-var resolveArrayType = (type2) => new import_graphql4.GraphQLList(resolveType(type2[0]));
-var resolvePlainObjectOrModelType = (type2) => {
-  const model = (0, import_schema2.getSchemaFromAnyOrionForm)(type2);
-  const fields = resolveModelFields(model);
-  return getCachedModelInput(model, fields);
-};
-var resolveType = (type2) => {
+var registeredGraphQLTypes = /* @__PURE__ */ new Map();
+var resolveType = (type2, options) => {
   var _a;
   if (!type2) throw new Error("No type specified");
   if ((_a = type2 == null ? void 0 : type2[Symbol.metadata]) == null ? void 0 : _a._getModel) {
     const model = type2[Symbol.metadata]._getModel();
-    return resolveType(model);
+    return resolveType(model, options);
   }
-  if (Array.isArray(type2)) return resolveArrayType(type2);
-  if (!type2.__isFieldType && (isType("Object", type2) || type2.__isModel)) {
-    return resolvePlainObjectOrModelType(type2);
+  if (Array.isArray(type2)) {
+    return new import_graphql4.GraphQLList(resolveType(type2[0], options));
+  }
+  if ((0, import_schema2.isSchemaLike)(type2)) {
+    const schema = (0, import_schema2.getSchemaWithMetadataFromAnyOrionForm)(type2);
+    const modelName = `${schema.__modelName}Input`;
+    if (schema.__graphQLType) {
+      return schema.__graphQLType;
+    }
+    if (!schema.__modelName) {
+      throw new Error(
+        `Schema name is not defined. Register a name with schemaWithName. Schema: ${JSON.stringify(schema)}`
+      );
+    }
+    if (registeredGraphQLTypes.has(modelName)) {
+      const { graphQLType: graphQLType2, schema: registeredSchema } = registeredGraphQLTypes.get(modelName);
+      if (equals(registeredSchema, schema)) {
+        return graphQLType2;
+      }
+      throw new Error(`Schema named "${modelName}" already registered`);
+    }
+    const graphQLType = createGraphQLInputType(modelName, schema, options);
+    registeredGraphQLTypes.set(modelName, { schema, graphQLType });
+    return graphQLType;
   }
   const schemaType = (0, import_schema2.getFieldType)(type2);
   return getScalar_default(schemaType);
 };
 var getField_default = resolveType;
+var createGraphQLInputType = (modelName, schema, options) => new import_graphql4.GraphQLInputObjectType({
+  name: modelName,
+  fields: () => buildFields(schema, options)
+});
+var buildFields = (schema, options) => {
+  const fields = {};
+  const addStaticFields = () => {
+    for (const field of getStaticFields(schema)) {
+      try {
+        fields[field.key] = { type: resolveType(field.type, options) };
+      } catch (error) {
+        throw new Error(`Error getting type for ${field.key}: ${error.message}`);
+      }
+    }
+  };
+  addStaticFields();
+  return fields;
+};
 
 // src/buildSchema/getArgs/index.ts
-async function getArgs_default(params) {
+async function getArgs_default(params, options) {
   if (!params) return;
   if (Object.keys(params).length === 0) return;
   const fields = {};
   for (const key of Object.keys(params).filter((key2) => !key2.startsWith("__"))) {
     try {
-      const type2 = getField_default(params[key].type);
+      const type2 = getField_default(params[key].type, options);
       fields[key] = { type: type2 };
     } catch (error) {
       throw new Error(`Error creating GraphQL resolver params argument ${key}: ${error.message}`);
@@ -739,7 +755,7 @@ function errorHandler(error, data) {
 // src/buildSchema/getType/getTypeAsResolver.ts
 function getTypeAsResolver_default({ resolver, getGraphQLType: getGraphQLType2, options, schema }) {
   const type2 = getGraphQLType2(resolver.returns, options);
-  const args = getArgs_default(resolver.params);
+  const args = getArgs_default(resolver.params, options);
   return {
     type: type2,
     args,
@@ -797,9 +813,9 @@ function getModelLoadedResolvers(schema, options) {
 // src/buildSchema/getType/index.ts
 var createGraphQLObjectType = (modelName, schema, options) => new import_graphql6.GraphQLObjectType({
   name: modelName,
-  fields: () => buildFields(schema, options)
+  fields: () => buildFields2(schema, options)
 });
-var buildFields = (schema, options) => {
+var buildFields2 = (schema, options) => {
   const fields = {};
   const addStaticFields = () => {
     for (const field of getStaticFields(schema)) {
@@ -837,7 +853,7 @@ var buildFields = (schema, options) => {
   addModelLoadedResolvers();
   return fields;
 };
-var registeredGraphQLTypes = /* @__PURE__ */ new Map();
+var registeredGraphQLTypes2 = /* @__PURE__ */ new Map();
 function getGraphQLType(type2, options) {
   if (!type2) throw new Error("Type is undefined");
   if (Array.isArray(type2)) {
@@ -854,15 +870,15 @@ function getGraphQLType(type2, options) {
         `Schema name is not defined. Register a name with schemaWithName. Schema: ${JSON.stringify(schema)}`
       );
     }
-    if (registeredGraphQLTypes.has(modelName)) {
-      const { graphQLType: graphQLType2, schema: registeredSchema } = registeredGraphQLTypes.get(modelName);
+    if (registeredGraphQLTypes2.has(modelName)) {
+      const { graphQLType: graphQLType2, schema: registeredSchema } = registeredGraphQLTypes2.get(modelName);
       if (equals(registeredSchema, schema)) {
         return graphQLType2;
       }
       throw new Error(`Schema named "${modelName}" already registered`);
     }
     const graphQLType = createGraphQLObjectType(modelName, schema, options);
-    registeredGraphQLTypes.set(modelName, { schema, graphQLType });
+    registeredGraphQLTypes2.set(modelName, { schema, graphQLType });
     return graphQLType;
   }
   return getScalar_default((0, import_schema3.getFieldType)(type2));
@@ -884,7 +900,7 @@ async function getResolvers_default(options, mutation) {
   for (const { resolver, name } of filteredResolvers) {
     resolversStore[name] = resolver;
     const type2 = await getGraphQLType(resolver.returns, options);
-    const args = await getArgs_default(resolver.params);
+    const args = await getArgs_default(resolver.params, options);
     fields[name] = {
       type: type2,
       args,
@@ -934,7 +950,7 @@ async function getSubscriptions_default(options) {
     const subscription = subscriptions[key];
     subscription.name = subscription.name || key;
     const type2 = await getGraphQLType(subscription.returns, options);
-    const args = await getArgs_default(subscription.params);
+    const args = await getArgs_default(subscription.params, options);
     fields[subscription.name] = {
       type: type2,
       args,
@@ -1164,13 +1180,10 @@ async function serializeSchema(params) {
   const schema = (0, import_schema6.getSchemaFromAnyOrionForm)(params);
   if (Object.keys(schema).length === 0) return;
   const fields = {};
-  console.log(schema, "schema");
   for (const key of Object.keys(schema).filter((key2) => !key2.startsWith("__"))) {
     const field = schema[key];
     fields[key] = await getParams(field);
-    console.log(fields[key], field);
   }
-  console.log(fields, "fields");
   return fields;
 }