@orion-js/graphql 4.0.10 → 4.0.11

package/dist/index.js

@@ -264,8 +264,8 @@ import { GraphQLObjectType as GraphQLObjectType2 } from "graphql";
 import { GraphQLList as GraphQLList2, GraphQLObjectType } from "graphql";
 import {
   getFieldType as getFieldType2,
-  getSchemaWithMetadataFromAnyOrionForm,
-  isSchemaLike
+  getSchemaWithMetadataFromAnyOrionForm as getSchemaWithMetadataFromAnyOrionForm2,
+  isSchemaLike as isSchemaLike2
 } from "@orion-js/schema";
 
 // ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/type.js
@@ -567,8 +567,12 @@ function getScalar_default(fieldType) {
 }
 
 // src/buildSchema/getArgs/getField.ts
-import { GraphQLList, GraphQLInputObjectType } from "graphql";
-import { getFieldType, getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2 } from "@orion-js/schema";
+import { GraphQLInputObjectType, GraphQLList } from "graphql";
+import {
+  getFieldType,
+  getSchemaWithMetadataFromAnyOrionForm,
+  isSchemaLike
+} from "@orion-js/schema";
 
 // src/resolversSchemas/getStaticFields.ts
 function getStaticFields(schema) {
@@ -587,54 +591,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 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 GraphQLList(resolveType(type2[0]));
-var resolvePlainObjectOrModelType = (type2) => {
-  const model = getSchemaFromAnyOrionForm2(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 GraphQLList(resolveType(type2[0], options));
+  }
+  if (isSchemaLike(type2)) {
+    const schema = 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 = getFieldType(type2);
   return getScalar_default(schemaType);
 };
 var getField_default = resolveType;
+var createGraphQLInputType = (modelName, schema, options) => new 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}`);
@@ -678,7 +698,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,
@@ -736,9 +756,9 @@ function getModelLoadedResolvers(schema, options) {
 // src/buildSchema/getType/index.ts
 var createGraphQLObjectType = (modelName, schema, options) => new 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)) {
@@ -776,14 +796,14 @@ 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)) {
     return new GraphQLList2(getGraphQLType(type2[0], options));
   }
-  if (isSchemaLike(type2)) {
-    const schema = getSchemaWithMetadataFromAnyOrionForm(type2);
+  if (isSchemaLike2(type2)) {
+    const schema = getSchemaWithMetadataFromAnyOrionForm2(type2);
     const modelName = schema.__modelName;
     if (schema.__graphQLType) {
       return schema.__graphQLType;
@@ -793,15 +813,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(getFieldType2(type2));
@@ -823,7 +843,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,
@@ -873,7 +893,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,
@@ -1056,13 +1076,13 @@ var ResolverParamsInfo_default = schemaWithName("ResolverParams", {
 });
 
 // src/resolversSchemas/serializeSchema.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3 } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2 } from "@orion-js/schema";
 
 // src/resolversSchemas/getField.ts
 import {
   getFieldType as getFieldType3,
-  getSchemaWithMetadataFromAnyOrionForm as getSchemaWithMetadataFromAnyOrionForm2,
-  isSchemaLike as isSchemaLike2
+  getSchemaWithMetadataFromAnyOrionForm as getSchemaWithMetadataFromAnyOrionForm3,
+  isSchemaLike as isSchemaLike3
 } from "@orion-js/schema";
 async function getParams(field) {
   const { type: type2 } = field;
@@ -1074,9 +1094,9 @@ async function getParams(field) {
       __graphQLType: `[${serialized.__graphQLType}]`
     };
   }
-  const isSchema = isSchemaLike2(type2);
+  const isSchema = isSchemaLike3(type2);
   if (isSchema) {
-    const schemaOfType = getSchemaWithMetadataFromAnyOrionForm2(type2);
+    const schemaOfType = getSchemaWithMetadataFromAnyOrionForm3(type2);
     const modelName = schemaOfType.__modelName;
     if (!modelName) {
       throw new Error("The schema needs a model name to be serialized for GraphQL");
@@ -1104,24 +1124,21 @@ async function getParams(field) {
 // src/resolversSchemas/serializeSchema.ts
 async function serializeSchema(params) {
   if (!params) return;
-  const schema = getSchemaFromAnyOrionForm3(params);
+  const schema = getSchemaFromAnyOrionForm2(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;
 }
 
 // src/resolversSchemas/params.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm5, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm4, isSchemaLike as isSchemaLike5 } from "@orion-js/schema";
 
 // src/resolversSchemas/getBasicResultQuery.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm4, isSchemaLike as isSchemaLike3 } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
 async function getBasicQuery(field) {
   if (!field.type) return "";
   if (Array.isArray(field.type)) {
@@ -1130,10 +1147,10 @@ async function getBasicQuery(field) {
       type: field.type[0]
     });
   }
-  if (!isSchemaLike3(field.type)) {
+  if (!isSchemaLike4(field.type)) {
     return field.key;
   }
-  const schema = getSchemaFromAnyOrionForm4(field.type);
+  const schema = getSchemaFromAnyOrionForm3(field.type);
   const fields = [];
   for (const field2 of getStaticFields(schema)) {
     fields.push(await getBasicQuery(field2));
@@ -1145,14 +1162,14 @@ async function getBasicQuery(field) {
 // src/resolversSchemas/params.ts
 function getResultTypeName(type2) {
   const returns = Array.isArray(type2) ? type2[0] : type2;
-  const schema = getSchemaFromAnyOrionForm5(returns);
+  const schema = getSchemaFromAnyOrionForm4(returns);
   if (schema == null ? void 0 : schema.__modelName) return schema.__modelName;
   return;
 }
 async function getInternalBasicResultQuery(type2) {
   const returns = Array.isArray(type2) ? type2[0] : type2;
-  if (isSchemaLike4(returns)) {
-    const schema = getSchemaFromAnyOrionForm5(returns);
+  if (isSchemaLike5(returns)) {
+    const schema = getSchemaFromAnyOrionForm4(returns);
     return await getBasicQuery({
       type: schema
     });