@orion-js/graphql 4.2.1 → 4.2.3

package/dist/index.cjs

@@ -84,6 +84,20 @@ function getChannelName_default(name, params) {
 }
 
 // src/subscription/index.ts
+var unauthorizedIterator = {
+  async next() {
+    return { value: void 0, done: true };
+  },
+  async return() {
+    return { value: void 0, done: true };
+  },
+  async throw(error) {
+    throw error;
+  },
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
 var createSubscription = (options) => {
   const subscription = {};
   const getSubscriptionName = () => {
@@ -103,13 +117,13 @@ var createSubscription = (options) => {
       if (options.canSubscribe) {
         const canSubscribe = await options.canSubscribe(params, viewer);
         if (!canSubscribe) {
-          return pubsub2.asyncIterator("unauthorized");
+          return unauthorizedIterator;
         }
       }
       const channelName = getChannelName_default(getSubscriptionName(), params);
       return pubsub2.asyncIterator(channelName);
     } catch (_error) {
-      return pubsub2.asyncIterator("unauthorized");
+      return unauthorizedIterator;
     }
   };
   subscription.params = (0, import_schema.getSchemaFromAnyOrionForm)(options.params) ?? {};
@@ -325,9 +339,159 @@ var import_graphql10 = require("graphql");
 // src/buildSchema/getQuery.ts
 var import_graphql7 = require("graphql");
 
-// src/buildSchema/getType/index.ts
-var import_graphql6 = require("graphql");
-var import_schema3 = require("@orion-js/schema");
+// src/buildSchema/getResolvers/index.ts
+var import_logger2 = require("@orion-js/logger");
+
+// src/errorHandler.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_graphql = require("graphql");
+function errorHandler(error, data) {
+  const message = `Error in resolver "${data.name}" ${data.schema ? `of model "${data.schema.__modelName}"` : ""}`;
+  const hash = import_node_crypto.default.createHash("sha1").update(error.message, "utf8").digest("hex").substring(0, 10);
+  error.hash = hash;
+  if (error == null ? void 0 : error.isOrionError) {
+    console.warn(message, error);
+    throw new import_graphql.GraphQLError(error.message, {
+      originalError: error,
+      extensions: {
+        isOrionError: !!error.isOrionError,
+        isValidationError: !!error.isValidationError,
+        code: error.code,
+        hash,
+        info: error.getInfo()
+      }
+    });
+  }
+  console.error(message, error);
+  throw new import_graphql.GraphQLError(`${error.message} [${hash}]`, {
+    // originalError: error,
+    extensions: {
+      isOrionError: false,
+      isValidationError: false,
+      code: "INTERNAL_SERVER_ERROR",
+      hash
+    }
+  });
+}
+
+// src/buildSchema/getArgs/getField.ts
+var import_graphql5 = require("graphql");
+var import_schema2 = require("@orion-js/schema");
+
+// src/buildSchema/getType/BigIntScalar.ts
+var import_graphql2 = require("graphql");
+var MAX_INT = Number.MAX_SAFE_INTEGER;
+var MIN_INT = Number.MIN_SAFE_INTEGER;
+var coerceBigInt = function coerceBigInt2(value) {
+  if (value === "") {
+    throw new TypeError("BigInt cannot represent non 53-bit signed integer value: (empty string)");
+  }
+  const num = Number(value);
+  if (num > MAX_INT || num < MIN_INT) {
+    throw new TypeError("BigInt cannot represent non 53-bit signed integer value: " + String(value));
+  }
+  const int = Math.floor(num);
+  if (int !== num) {
+    throw new TypeError("BigInt cannot represent non-integer value: " + String(value));
+  }
+  return int;
+};
+var BigIntScalar_default = new import_graphql2.GraphQLScalarType({
+  name: "BigInt",
+  description: "The `BigInt` scalar type represents non-fractional signed whole numeric values. BigInt can represent values between -(2^53) + 1 and 2^53 - 1. ",
+  serialize: coerceBigInt,
+  parseValue: coerceBigInt,
+  parseLiteral(ast) {
+    if (ast.kind === "IntValue") {
+      const num = parseInt(ast.value, 10);
+      if (num <= MAX_INT && num >= MIN_INT) {
+        return num;
+      }
+    }
+    return null;
+  }
+});
+
+// src/buildSchema/getType/DateScalar.ts
+var import_graphql3 = require("graphql");
+var import_graphql_scalars = require("graphql-scalars");
+var DateScalar_default = new import_graphql3.GraphQLScalarType({
+  name: "Date",
+  serialize: import_graphql_scalars.GraphQLDateTime.serialize,
+  parseValue: import_graphql_scalars.GraphQLDateTime.parseValue,
+  parseLiteral: import_graphql_scalars.GraphQLDateTime.parseLiteral
+});
+
+// src/buildSchema/getType/JSONScalar.ts
+var import_graphql4 = require("graphql");
+function identity(value) {
+  return value;
+}
+function parseLiteral(ast, variables) {
+  switch (ast.kind) {
+    case import_graphql4.Kind.STRING:
+    case import_graphql4.Kind.BOOLEAN:
+      return ast.value;
+    case import_graphql4.Kind.INT:
+    case import_graphql4.Kind.FLOAT:
+      return parseFloat(ast.value);
+    case import_graphql4.Kind.OBJECT: {
+      const value = /* @__PURE__ */ Object.create(null);
+      ast.fields.forEach((field) => {
+        value[field.name.value] = parseLiteral(field.value, variables);
+      });
+      return value;
+    }
+    case import_graphql4.Kind.LIST:
+      return ast.values.map((n) => parseLiteral(n, variables));
+    case import_graphql4.Kind.NULL:
+      return null;
+    case import_graphql4.Kind.VARIABLE: {
+      const name = ast.name.value;
+      return variables ? variables[name] : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+var JSONScalar_default = new import_graphql4.GraphQLScalarType({
+  name: "JSON",
+  description: "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
+  serialize: identity,
+  parseValue: identity,
+  parseLiteral
+});
+
+// src/buildSchema/getType/getScalar.ts
+var GraphQL = __toESM(require("graphql"), 1);
+var { GraphQLFloat, GraphQLString, GraphQLID, GraphQLBoolean } = GraphQL;
+var fieldMap = {
+  string: GraphQLString,
+  email: GraphQLString,
+  date: DateScalar_default,
+  integer: BigIntScalar_default,
+  number: GraphQLFloat,
+  ID: GraphQLID,
+  boolean: GraphQLBoolean,
+  blackbox: JSONScalar_default,
+  any: JSONScalar_default
+};
+function getScalar_default(fieldType) {
+  if (fieldMap[fieldType.name]) {
+    return fieldMap[fieldType.name];
+  }
+  if (fieldType.name.startsWith("typedId:")) {
+    return fieldMap.string;
+  }
+  if (fieldType.toGraphQLType) {
+    const result = fieldType.toGraphQLType(GraphQL);
+    if (result.then) {
+      throw new Error("toGraphQLType cant return a promise");
+    }
+    return result;
+  }
+  throw new Error(`Field type "${fieldType.name}" has no convertion to GraphQLType`);
+}
 
 // ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/type.js
 function type(input) {
@@ -512,125 +676,6 @@ function isEmpty(input) {
   return false;
 }
 
-// src/buildSchema/getType/BigIntScalar.ts
-var import_graphql = require("graphql");
-var MAX_INT = Number.MAX_SAFE_INTEGER;
-var MIN_INT = Number.MIN_SAFE_INTEGER;
-var coerceBigInt = function coerceBigInt2(value) {
-  if (value === "") {
-    throw new TypeError("BigInt cannot represent non 53-bit signed integer value: (empty string)");
-  }
-  const num = Number(value);
-  if (num > MAX_INT || num < MIN_INT) {
-    throw new TypeError("BigInt cannot represent non 53-bit signed integer value: " + String(value));
-  }
-  const int = Math.floor(num);
-  if (int !== num) {
-    throw new TypeError("BigInt cannot represent non-integer value: " + String(value));
-  }
-  return int;
-};
-var BigIntScalar_default = new import_graphql.GraphQLScalarType({
-  name: "BigInt",
-  description: "The `BigInt` scalar type represents non-fractional signed whole numeric values. BigInt can represent values between -(2^53) + 1 and 2^53 - 1. ",
-  serialize: coerceBigInt,
-  parseValue: coerceBigInt,
-  parseLiteral(ast) {
-    if (ast.kind === "IntValue") {
-      const num = parseInt(ast.value, 10);
-      if (num <= MAX_INT && num >= MIN_INT) {
-        return num;
-      }
-    }
-    return null;
-  }
-});
-
-// src/buildSchema/getType/DateScalar.ts
-var import_graphql2 = require("graphql");
-var import_graphql_scalars = require("graphql-scalars");
-var DateScalar_default = new import_graphql2.GraphQLScalarType({
-  name: "Date",
-  serialize: import_graphql_scalars.GraphQLDateTime.serialize,
-  parseValue: import_graphql_scalars.GraphQLDateTime.parseValue,
-  parseLiteral: import_graphql_scalars.GraphQLDateTime.parseLiteral
-});
-
-// src/buildSchema/getType/JSONScalar.ts
-var import_graphql3 = require("graphql");
-function identity(value) {
-  return value;
-}
-function parseLiteral(ast, variables) {
-  switch (ast.kind) {
-    case import_graphql3.Kind.STRING:
-    case import_graphql3.Kind.BOOLEAN:
-      return ast.value;
-    case import_graphql3.Kind.INT:
-    case import_graphql3.Kind.FLOAT:
-      return parseFloat(ast.value);
-    case import_graphql3.Kind.OBJECT: {
-      const value = /* @__PURE__ */ Object.create(null);
-      ast.fields.forEach((field) => {
-        value[field.name.value] = parseLiteral(field.value, variables);
-      });
-      return value;
-    }
-    case import_graphql3.Kind.LIST:
-      return ast.values.map((n) => parseLiteral(n, variables));
-    case import_graphql3.Kind.NULL:
-      return null;
-    case import_graphql3.Kind.VARIABLE: {
-      const name = ast.name.value;
-      return variables ? variables[name] : void 0;
-    }
-    default:
-      return void 0;
-  }
-}
-var JSONScalar_default = new import_graphql3.GraphQLScalarType({
-  name: "JSON",
-  description: "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
-  serialize: identity,
-  parseValue: identity,
-  parseLiteral
-});
-
-// src/buildSchema/getType/getScalar.ts
-var GraphQL = __toESM(require("graphql"), 1);
-var { GraphQLFloat, GraphQLString, GraphQLID, GraphQLBoolean } = GraphQL;
-var fieldMap = {
-  string: GraphQLString,
-  email: GraphQLString,
-  date: DateScalar_default,
-  integer: BigIntScalar_default,
-  number: GraphQLFloat,
-  ID: GraphQLID,
-  boolean: GraphQLBoolean,
-  blackbox: JSONScalar_default,
-  any: JSONScalar_default
-};
-function getScalar_default(fieldType) {
-  if (fieldMap[fieldType.name]) {
-    return fieldMap[fieldType.name];
-  }
-  if (fieldType.name.startsWith("typedId:")) {
-    return fieldMap.string;
-  }
-  if (fieldType.toGraphQLType) {
-    const result = fieldType.toGraphQLType(GraphQL);
-    if (result.then) {
-      throw new Error("toGraphQLType cant return a promise");
-    }
-    return result;
-  }
-  throw new Error(`Field type "${fieldType.name}" has no convertion to GraphQLType`);
-}
-
-// src/buildSchema/getArgs/getField.ts
-var import_graphql4 = require("graphql");
-var import_schema2 = require("@orion-js/schema");
-
 // src/resolversSchemas/getStaticFields.ts
 function getStaticFields(schema) {
   if (!schema) return [];
@@ -657,7 +702,7 @@ var resolveType = (type2, options) => {
     return resolveType(model, options);
   }
   if (Array.isArray(type2)) {
-    return new import_graphql4.GraphQLList(resolveType(type2[0], options));
+    return new import_graphql5.GraphQLList(resolveType(type2[0], options));
   }
   if ((0, import_schema2.isSchemaLike)(type2)) {
     const schema = (0, import_schema2.getSchemaWithMetadataFromAnyOrionForm)(type2);
@@ -685,7 +730,7 @@ var resolveType = (type2, options) => {
   return getScalar_default(schemaType);
 };
 var getField_default = resolveType;
-var createGraphQLInputType = (modelName, schema, options) => new import_graphql4.GraphQLInputObjectType({
+var createGraphQLInputType = (modelName, schema, options) => new import_graphql5.GraphQLInputObjectType({
   name: modelName,
   fields: () => buildFields(schema, options)
 });
@@ -720,37 +765,9 @@ function getArgs_default(params, options) {
   return fields;
 }
 
-// src/errorHandler.ts
-var import_node_crypto = __toESM(require("crypto"), 1);
-var import_graphql5 = require("graphql");
-function errorHandler(error, data) {
-  const message = `Error in resolver "${data.name}" ${data.schema ? `of model "${data.schema.__modelName}"` : ""}`;
-  const hash = import_node_crypto.default.createHash("sha1").update(error.message, "utf8").digest("hex").substring(0, 10);
-  error.hash = hash;
-  if (error == null ? void 0 : error.isOrionError) {
-    console.warn(message, error);
-    throw new import_graphql5.GraphQLError(error.message, {
-      originalError: error,
-      extensions: {
-        isOrionError: !!error.isOrionError,
-        isValidationError: !!error.isValidationError,
-        code: error.code,
-        hash,
-        info: error.getInfo()
-      }
-    });
-  }
-  console.error(message, error);
-  throw new import_graphql5.GraphQLError(`${error.message} [${hash}]`, {
-    // originalError: error,
-    extensions: {
-      isOrionError: false,
-      isValidationError: false,
-      code: "INTERNAL_SERVER_ERROR",
-      hash
-    }
-  });
-}
+// src/buildSchema/getType/index.ts
+var import_graphql6 = require("graphql");
+var import_schema3 = require("@orion-js/schema");
 
 // src/buildSchema/getType/getTypeAsResolver.ts
 var import_logger = require("@orion-js/logger");
@@ -900,17 +917,17 @@ function getGraphQLType(type2, options) {
 var resolversStore = {};
 
 // src/buildSchema/getResolvers/index.ts
-var import_logger2 = require("@orion-js/logger");
 async function getResolvers_default(options, mutation) {
   const { resolvers } = options;
-  const filteredResolvers = Object.keys(resolvers).map((key) => {
-    return {
-      name: key,
-      resolver: resolvers[key]
-    };
-  }).filter(({ resolver }) => !!resolver.mutation === !!mutation).filter(({ resolver }) => !resolver.private);
   const fields = {};
-  for (const { resolver, name } of filteredResolvers) {
+  for (const name of Object.keys(resolvers)) {
+    const resolver = resolvers[name];
+    if (!!resolver.mutation !== !!mutation) {
+      continue;
+    }
+    if (resolver.private) {
+      continue;
+    }
     resolversStore[name] = resolver;
     const type2 = await getGraphQLType(resolver.returns, options);
     const args = await getArgs_default(resolver.params, options);