@orion-js/graphql 4.0.0-next.4 → 4.0.0-next.6

package/dist/index.js

@@ -51,7 +51,7 @@ import { registerRoute, route } from "@orion-js/http";
 function safeSerialize(data) {
   return data ? JSON.stringify(data).replace(/\//g, "\\/") : null;
 }
-var getHTML = function(apolloOptions, options, data) {
+var getHTML = (_apolloOptions, options, data) => {
   const GRAPHIQL_VERSION = "0.11.11";
   const endpointURL = "/graphql";
   const subscriptionsEndpoint = "/subscriptions";
@@ -254,7 +254,6 @@ import { GraphQLSchema } from "graphql";
 import { GraphQLObjectType as GraphQLObjectType2 } from "graphql";
 
 // src/buildSchema/getType/index.ts
-import isArray2 from "lodash/isArray";
 import { GraphQLList as GraphQLList2, GraphQLObjectType } from "graphql";
 import {
   getFieldType as getFieldType2,
@@ -262,6 +261,189 @@ import {
   isSchemaLike
 } from "@orion-js/schema";
 
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/type.js
+function type(input) {
+  if (input === null) {
+    return "Null";
+  } else if (input === void 0) {
+    return "Undefined";
+  } else if (Number.isNaN(input)) {
+    return "NaN";
+  }
+  const typeResult = Object.prototype.toString.call(input).slice(8, -1);
+  return typeResult === "AsyncFunction" ? "Promise" : typeResult;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/isArray.js
+var { isArray } = Array;
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/isInteger.js
+function _isInteger(n) {
+  return n << 0 === n;
+}
+var isInteger = Number.isInteger || _isInteger;
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/createPath.js
+function createPath(path, delimiter = ".") {
+  return typeof path === "string" ? path.split(delimiter).map((x) => isInteger(x) ? Number(x) : x) : path;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/equals.js
+function _indexOf(valueToFind, list) {
+  if (!isArray(list))
+    throw new Error(`Cannot read property 'indexOf' of ${list}`);
+  const typeOfValue = type(valueToFind);
+  if (!["Array", "NaN", "Object", "RegExp"].includes(typeOfValue))
+    return list.indexOf(valueToFind);
+  let index = -1;
+  let foundIndex = -1;
+  const { length } = list;
+  while (++index < length && foundIndex === -1)
+    if (equals(list[index], valueToFind))
+      foundIndex = index;
+  return foundIndex;
+}
+function _arrayFromIterator(iter) {
+  const list = [];
+  let next;
+  while (!(next = iter.next()).done)
+    list.push(next.value);
+  return list;
+}
+function _compareSets(a, b) {
+  if (a.size !== b.size)
+    return false;
+  const aList = _arrayFromIterator(a.values());
+  const bList = _arrayFromIterator(b.values());
+  const filtered = aList.filter((aInstance) => _indexOf(aInstance, bList) === -1);
+  return filtered.length === 0;
+}
+function compareErrors(a, b) {
+  if (a.message !== b.message) return false;
+  if (a.toString !== b.toString) return false;
+  return a.toString() === b.toString();
+}
+function parseDate(maybeDate) {
+  if (!maybeDate.toDateString) return [false];
+  return [true, maybeDate.getTime()];
+}
+function parseRegex(maybeRegex) {
+  if (maybeRegex.constructor !== RegExp) return [false];
+  return [true, maybeRegex.toString()];
+}
+function equals(a, b) {
+  if (arguments.length === 1) return (_b) => equals(a, _b);
+  if (Object.is(a, b)) return true;
+  const aType = type(a);
+  if (aType !== type(b)) return false;
+  if (aType === "Function")
+    return a.name === void 0 ? false : a.name === b.name;
+  if (["NaN", "Null", "Undefined"].includes(aType)) return true;
+  if (["BigInt", "Number"].includes(aType)) {
+    if (Object.is(-0, a) !== Object.is(-0, b)) return false;
+    return a.toString() === b.toString();
+  }
+  if (["Boolean", "String"].includes(aType))
+    return a.toString() === b.toString();
+  if (aType === "Array") {
+    const aClone = Array.from(a);
+    const bClone = Array.from(b);
+    if (aClone.toString() !== bClone.toString())
+      return false;
+    let loopArrayFlag = true;
+    aClone.forEach((aCloneInstance, aCloneIndex) => {
+      if (loopArrayFlag) {
+        if (aCloneInstance !== bClone[aCloneIndex] && !equals(aCloneInstance, bClone[aCloneIndex]))
+          loopArrayFlag = false;
+      }
+    });
+    return loopArrayFlag;
+  }
+  const aRegex = parseRegex(a);
+  const bRegex = parseRegex(b);
+  if (aRegex[0])
+    return bRegex[0] ? aRegex[1] === bRegex[1] : false;
+  else if (bRegex[0]) return false;
+  const aDate = parseDate(a);
+  const bDate = parseDate(b);
+  if (aDate[0])
+    return bDate[0] ? aDate[1] === bDate[1] : false;
+  else if (bDate[0]) return false;
+  if (a instanceof Error) {
+    if (!(b instanceof Error)) return false;
+    return compareErrors(a, b);
+  }
+  if (aType === "Set")
+    return _compareSets(a, b);
+  if (aType === "Object") {
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length)
+      return false;
+    let loopObjectFlag = true;
+    aKeys.forEach((aKeyInstance) => {
+      if (loopObjectFlag) {
+        const aValue = a[aKeyInstance];
+        const bValue = b[aKeyInstance];
+        if (aValue !== bValue && !equals(aValue, bValue))
+          loopObjectFlag = false;
+      }
+    });
+    return loopObjectFlag;
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isType.js
+function isType(xType, x) {
+  if (arguments.length === 1) {
+    return (xHolder) => isType(xType, xHolder);
+  }
+  return type(x) === xType;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/compare.js
+function compare(a, b) {
+  return String(a) === String(b);
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/includes.js
+function includes(a, list) {
+  let index = -1;
+  const { length } = list;
+  while (++index < length)
+    if (compare(list[index], a))
+      return true;
+  return false;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/omit.js
+function omit(propsToOmit, obj) {
+  if (arguments.length === 1) return (_obj) => omit(propsToOmit, _obj);
+  if (obj === null || obj === void 0)
+    return void 0;
+  const propsToOmitValue = createPath(propsToOmit, ",");
+  const willReturn = {};
+  for (const key in obj)
+    if (!includes(key, propsToOmitValue))
+      willReturn[key] = obj[key];
+  return willReturn;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isEmpty.js
+function isEmpty(input) {
+  const inputType = type(input);
+  if (["Undefined", "NaN", "Number", "Null"].includes(inputType))
+    return false;
+  if (!input) return true;
+  if (inputType === "Object") {
+    return Object.keys(input).length === 0;
+  }
+  if (inputType === "Array") {
+    return input.length === 0;
+  }
+  return false;
+}
+
 // src/buildSchema/getType/BigIntScalar.ts
 import { GraphQLScalarType } from "graphql";
 var MAX_INT = Number.MAX_SAFE_INTEGER;
@@ -375,8 +557,6 @@ function getScalar_default(fieldType) {
 }
 
 // src/buildSchema/getArgs/getField.ts
-import isPlainObject from "lodash/isPlainObject";
-import isArray from "lodash/isArray";
 import { GraphQLList, GraphQLInputObjectType } from "graphql";
 import { getFieldType } from "@orion-js/schema";
 
@@ -415,27 +595,27 @@ var resolveModelFields = (model) => {
   }
   return fields;
 };
-var resolveArrayType = (type) => new GraphQLList(resolveType(type[0]));
-var resolvePlainObjectOrModelType = (type) => {
-  const model = type.__isModel ? type : type.__model;
+var resolveArrayType = (type2) => new GraphQLList(resolveType(type2[0]));
+var resolvePlainObjectOrModelType = (type2) => {
+  const model = type2.__isModel ? type2 : type2.__model;
   if (!model || !model.__isModel) {
     throw new Error("A type is not a Model");
   }
   const fields = resolveModelFields(model);
   return getCachedModelInput(model, fields);
 };
-var resolveType = (type) => {
+var resolveType = (type2) => {
   var _a;
-  if (!type) throw new Error("No type specified");
-  if ((_a = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _a._getModel) {
-    const model = type[Symbol.metadata]._getModel();
+  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);
   }
-  if (isArray(type)) return resolveArrayType(type);
-  if (!type.__isFieldType && (isPlainObject(type) || type.__isModel)) {
-    return resolvePlainObjectOrModelType(type);
+  if (Array.isArray(type2)) return resolveArrayType(type2);
+  if (!type2.__isFieldType && (isType("Object", type2) || type2.__isModel)) {
+    return resolvePlainObjectOrModelType(type2);
   }
-  const schemaType = getFieldType(type);
+  const schemaType = getFieldType(type2);
   return getScalar_default(schemaType);
 };
 var getField_default = resolveType;
@@ -447,8 +627,8 @@ async function getArgs_default(params) {
   const fields = {};
   for (const key of Object.keys(params)) {
     try {
-      const type = getField_default(params[key].type);
-      fields[key] = { type };
+      const type2 = getField_default(params[key].type);
+      fields[key] = { type: type2 };
     } catch (error) {
       throw new Error(`Error creating GraphQL resolver params argument ${key}: ${error.message}`);
     }
@@ -490,10 +670,10 @@ function errorHandler(error, data) {
 
 // src/buildSchema/getType/getTypeAsResolver.ts
 function getTypeAsResolver_default({ resolver: resolver2, getGraphQLType: getGraphQLType2, options, schema }) {
-  const type = getGraphQLType2(resolver2.returns, options);
+  const type2 = getGraphQLType2(resolver2.returns, options);
   const args = getArgs_default(resolver2.params);
   return {
-    type,
+    type: type2,
     args,
     async resolve(item, params, context, info) {
       try {
@@ -547,7 +727,6 @@ function getModelLoadedResolvers(schema, options) {
 }
 
 // src/buildSchema/getType/index.ts
-import { isEqual } from "lodash";
 var createGraphQLObjectType = (modelName, schema, options) => new GraphQLObjectType({
   name: modelName,
   fields: () => buildFields(schema, options)
@@ -591,13 +770,13 @@ var buildFields = (schema, options) => {
   return fields;
 };
 var registeredGraphQLTypes = /* @__PURE__ */ new Map();
-function getGraphQLType(type, options) {
-  if (!type) throw new Error("Type is undefined");
-  if (isArray2(type)) {
-    return new GraphQLList2(getGraphQLType(type[0], options));
+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(type)) {
-    const schema = getSchemaWithMetadataFromAnyOrionForm(type);
+  if (isSchemaLike(type2)) {
+    const schema = getSchemaWithMetadataFromAnyOrionForm(type2);
     const modelName = schema.__modelName;
     if (schema.__graphQLType) {
       return schema.__graphQLType;
@@ -609,7 +788,7 @@ function getGraphQLType(type, options) {
     }
     if (registeredGraphQLTypes.has(modelName)) {
       const { graphQLType: graphQLType2, schema: registeredSchema } = registeredGraphQLTypes.get(modelName);
-      if (isEqual(registeredSchema, schema)) {
+      if (equals(registeredSchema, schema)) {
         return graphQLType2;
       }
       throw new Error(`Schema named "${modelName}" already registered`);
@@ -618,7 +797,7 @@ function getGraphQLType(type, options) {
     registeredGraphQLTypes.set(modelName, { schema, graphQLType });
     return graphQLType;
   }
-  return getScalar_default(getFieldType2(type));
+  return getScalar_default(getFieldType2(type2));
 }
 
 // src/buildSchema/getResolvers/resolversStore.ts
@@ -636,10 +815,10 @@ async function getResolvers_default(options, mutation) {
   const fields = {};
   for (const { resolver: resolver2, name } of filteredResolvers) {
     resolversStore[name] = resolver2;
-    const type = await getGraphQLType(resolver2.returns, options);
+    const type2 = await getGraphQLType(resolver2.returns, options);
     const args = await getArgs_default(resolver2.params);
     fields[name] = {
-      type,
+      type: type2,
       args,
       async resolve(_root, params, context, info) {
         try {
@@ -656,7 +835,6 @@ async function getResolvers_default(options, mutation) {
 }
 
 // src/buildSchema/getQuery.ts
-import isEmpty from "lodash/isEmpty";
 async function getQuery_default(options) {
   const fields = await getResolvers_default(options, false);
   if (isEmpty(fields)) return null;
@@ -668,10 +846,9 @@ async function getQuery_default(options) {
 
 // src/buildSchema/getMutation.ts
 import { GraphQLObjectType as GraphQLObjectType3 } from "graphql";
-import isEmpty2 from "lodash/isEmpty";
 async function getMutation_default(options) {
   const fields = await getResolvers_default(options, true);
-  if (isEmpty2(fields)) return null;
+  if (isEmpty(fields)) return null;
   return new GraphQLObjectType3({
     name: "Mutation",
     fields
@@ -688,10 +865,10 @@ async function getSubscriptions_default(options) {
   for (const key of Object.keys(subscriptions)) {
     const subscription = subscriptions[key];
     subscription.name = subscription.name || key;
-    const type = await getGraphQLType(subscription.returns, options);
+    const type2 = await getGraphQLType(subscription.returns, options);
     const args = await getArgs_default(subscription.params);
     fields[subscription.name] = {
-      type,
+      type: type2,
       args,
       async subscribe(root, params, viewer) {
         return await subscription.subscribe(params, viewer);
@@ -734,18 +911,20 @@ function formatError_default(apolloError) {
 }
 
 // src/getApolloOptions/index.ts
-import { omit } from "lodash";
 async function getApolloOptions_default(options) {
   const schema = await buildSchema_default(options);
-  const passedOptions = omit(options, [
-    "resolvers",
-    "modelResolvers",
-    "subscriptions",
-    "executeGraphQLCache",
-    "useGraphiql",
-    "app",
-    "pubsub"
-  ]);
+  const passedOptions = omit(
+    [
+      "resolvers",
+      "modelResolvers",
+      "subscriptions",
+      "executeGraphQLCache",
+      "useGraphiql",
+      "app",
+      "pubsub"
+    ],
+    options
+  );
   return {
     ...passedOptions,
     schema,
@@ -878,20 +1057,20 @@ import {
   getSchemaWithMetadataFromAnyOrionForm as getSchemaWithMetadataFromAnyOrionForm2,
   isSchemaLike as isSchemaLike2
 } from "@orion-js/schema";
-import omit2 from "lodash/omit";
 async function getParams(field) {
-  const { type } = field;
-  if (Array.isArray(type)) {
-    const serialized = await getParams({ ...field, type: type[0] });
+  const { type: type2 } = field;
+  console.log(type2, "getting parms");
+  if (Array.isArray(type2)) {
+    const serialized = await getParams({ ...field, type: type2[0] });
     return {
       ...serialized,
       type: [serialized.type],
       __graphQLType: `[${serialized.__graphQLType}]`
     };
   }
-  const isSchema = isSchemaLike2(type);
+  const isSchema = isSchemaLike2(type2);
   if (isSchema) {
-    const schemaOfType = getSchemaWithMetadataFromAnyOrionForm2(type);
+    const schemaOfType = getSchemaWithMetadataFromAnyOrionForm2(type2);
     const modelName = schemaOfType.__modelName;
     if (!modelName) {
       throw new Error("The schema needs a model name to be serialized for GraphQL");
@@ -901,31 +1080,34 @@ async function getParams(field) {
       fields[field2.key] = await getParams(field2);
     }
     return {
-      ...omit2(field, "key"),
+      ...omit(["key"], field),
       type: fields,
       __graphQLType: `${modelName}Input`
     };
   }
-  const schemaType = getFieldType3(type);
+  const schemaType = getFieldType3(type2);
   const graphQLType = await getScalar_default(schemaType);
+  const withoutKey = isType("Object", field) ? omit(["key"], field) : {};
   return {
-    ...omit2(field, "key"),
+    ...withoutKey,
     type: schemaType.name,
     __graphQLType: graphQLType.name
   };
 }
 
 // src/resolversSchemas/serializeSchema.ts
-Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 async function serializeSchema(params) {
   if (!params) return;
   const schema = 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;
 }
 
@@ -933,11 +1115,10 @@ async function serializeSchema(params) {
 import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
 
 // src/resolversSchemas/getBasicResultQuery.ts
-import isArray3 from "lodash/isArray";
 import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2, isSchemaLike as isSchemaLike3 } from "@orion-js/schema";
 async function getBasicQuery(field) {
   if (!field.type) return "";
-  if (isArray3(field.type)) {
+  if (Array.isArray(field.type)) {
     return getBasicQuery({
       ...field,
       type: field.type[0]
@@ -956,14 +1137,14 @@ async function getBasicQuery(field) {
 }
 
 // src/resolversSchemas/params.ts
-function getResultTypeName(type) {
-  const returns = Array.isArray(type) ? type[0] : type;
+function getResultTypeName(type2) {
+  const returns = Array.isArray(type2) ? type2[0] : type2;
   const schema = getSchemaFromAnyOrionForm3(returns);
   if (schema == null ? void 0 : schema.__modelName) return schema.__modelName;
   return;
 }
-async function getInternalBasicResultQuery(type) {
-  const returns = Array.isArray(type) ? type[0] : type;
+async function getInternalBasicResultQuery(type2) {
+  const returns = Array.isArray(type2) ? type2[0] : type2;
   if (isSchemaLike4(returns)) {
     const schema = getSchemaFromAnyOrionForm3(returns);
     return await getBasicQuery({
@@ -1026,10 +1207,10 @@ import { resolver } from "@orion-js/resolvers";
 
 // src/service/middlewares.ts
 var resolversMetadata = /* @__PURE__ */ new WeakMap();
-function addTargetMetadata(target, propertyKey, metadataKey, metadata, isArray4 = false) {
+function addTargetMetadata(target, propertyKey, metadataKey, metadata, isArray2 = false) {
   const targetMetadata = resolversMetadata.get(target) || {};
   targetMetadata[propertyKey] = targetMetadata[propertyKey] || {};
-  if (isArray4) {
+  if (isArray2) {
     targetMetadata[propertyKey][metadataKey] = targetMetadata[propertyKey][metadataKey] || [];
     targetMetadata[propertyKey][metadataKey].unshift(metadata);
   } else {