@nxgt/shared-graphql 1.0.0

package/dist/index.js

@@ -0,0 +1,907 @@
+// src/index.ts
+import DataLoader2 from "dataloader";
+
+export * from "graphql-subscriptions";
+
+// src/directives/federation.ts
+var FEDERATION_DIRECTIVES = `
+directive @external on FIELD_DEFINITION | OBJECT
+directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+directive @key(fields: FieldSet!, resolvable: Boolean = true) repeatable on OBJECT | INTERFACE
+directive @shareable repeatable on OBJECT | FIELD_DEFINITION
+directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+directive @tag(name: String!) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+directive @override(from: String!) on FIELD_DEFINITION
+directive @composeDirective(name: String!) repeatable on SCHEMA
+directive @interfaceObject on OBJECT
+directive @authenticated on FIELD_DEFINITION | OBJECT | INTERFACE | SCALAR | ENUM
+`;
+// src/integrations/hono.ts
+import { Hono } from "hono";
+import { contextStorage } from "hono/context-storage";
+import { createMiddleware } from "hono/factory";
+import { languageDetector } from "hono/language";
+
+// src/utils/change-resolvers.utils.ts
+import {
+  AUDIT_EVENT,
+  CommitType
+} from "@nxgt/shared-mongo";
+import { withFilter } from "graphql-subscriptions";
+function createChangeResolvers(config) {
+  const { entity, collection, service, pubsub } = config;
+  const resolvePubSub = () => typeof pubsub === "function" ? pubsub() : pubsub;
+  return {
+    Query: {
+      [`${entity}Changes`]: async (_parent, args, context) => context.services.audit.findChangesPaginatedByCollection(collection, args),
+      [`${entity}ChangesById`]: async (_parent, args, context) => context.services.audit.findChangesPaginatedByCollectionAndOid(args.id, collection, args)
+    },
+    Subscription: {
+      [`${entity}Changed`]: {
+        resolve: async (payload, _args, context) => ({
+          id: context.services.audit.extractId(payload),
+          data: payload.type !== CommitType.TERMINAL ? await context.services[service].findById(payload.state._id) : null,
+          type: payload.type
+        }),
+        subscribe: withFilter(() => resolvePubSub().subscribe(AUDIT_EVENT), (payload, _variables, context) => context ? context.services.audit.matches(payload, { collection }) : false)
+      }
+    }
+  };
+}
+// src/utils/codegen.utils.ts
+var SCALARS_MAPPING = {
+  ID: "any",
+  DateTime: "any",
+  Date: "any",
+  Any: "any",
+  BigInt: "number",
+  EmailAddress: "string",
+  GeoJSON: "any",
+  HSL: "string",
+  HSLA: "string",
+  HexColorCode: "string",
+  Hexadecimal: "string",
+  IBAN: "string",
+  IP: "string",
+  Time: "string",
+  LocalTime: "string",
+  UUID: "string",
+  PositiveInt: "number",
+  NegativeInt: "number",
+  NonPositiveInt: "number",
+  NonNegativeInt: "number",
+  PositiveFloat: "number",
+  NegativeFloat: "number",
+  NonPositiveFloat: "number",
+  NonNegativeFloat: "number",
+  NonEmptyString: "string",
+  PostalCode: "string",
+  RGB: "string",
+  RGBA: "string",
+  SESSN: "string",
+  Timestamp: "string",
+  URL: "string",
+  USCurrency: "string",
+  UTCOffset: "string",
+  Long: "number",
+  Short: "number",
+  Byte: "number",
+  BigDecimal: "string",
+  BigInteger: "string",
+  Char: "string",
+  Locale: "string",
+  CountryCode: "string",
+  CountryName: "string",
+  AccountNumber: "string",
+  CurrencyCode: "string",
+  Duration: "string",
+  Url: "string",
+  JSONObject: "Record<string, any>",
+  JSON: "any",
+  Void: "void",
+  ObjectID: "any",
+  Upload: "File | Blob",
+  Email: "string",
+  Port: "number",
+  IPv4: "string",
+  IPv6: "string",
+  MAC: "string",
+  Password: "string",
+  PhoneNumber: "string",
+  ZIPCode: "string",
+  SSN: "string",
+  GUID: "string",
+  ISBN: "string",
+  Latitude: "number",
+  Longitude: "number",
+  JWT: "string"
+};
+// src/utils/data-loader.utils.ts
+import { cast } from "@nxgt/shared/helpers";
+import {
+  paginateList
+} from "@nxgt/shared-mongo";
+import DataLoader from "dataloader";
+import { isArray } from "lodash";
+function createDataLoader(batchLoadFn, options) {
+  return new DataLoader(batchLoadFn, options);
+}
+function createConnectionListDataLoader(path, model, options) {
+  return createDataLoader(async (docs) => {
+    const data = await model.find({
+      ...options.filter ?? {},
+      _id: docs.flatMap((doc) => {
+        const ids = doc[path] ?? [];
+        return isArray(ids) ? cast(ids.filter((item) => !!item && !["undefined", "null"].includes(item?.toString()))) : [];
+      })
+    }).exec();
+    return cast(docs.map((doc) => model.paginateList(data.filter((child) => cast(doc[path] ?? []).map((item) => item.toString()).includes(child._id.toString())), options)));
+  });
+}
+function createChildrenConnectionDataLoader(path, model, options) {
+  return createDataLoader(async (docs) => {
+    const filter = {};
+    filter[path] = docs.map((doc) => doc._id);
+    const data = await model.find(filter).exec();
+    return cast(docs.map((doc) => paginateList(data.filter((child) => doc._id?.toString() === child[path]?.toString()), options)));
+  });
+}
+function createSimpleListDataLoader(path, model, options) {
+  return createDataLoader(async (docs) => {
+    const filter = options?.filter ?? {};
+    const ids = docs.flatMap((doc) => {
+      const ids2 = doc[path] ?? [];
+      return isArray(ids2) ? cast(ids2) : [];
+    });
+    filter._id = ids;
+    const query = model.find(filter);
+    const data = await query.exec();
+    return cast(docs.map((doc) => {
+      const result = data.filter((child) => cast(doc[path] ?? []).map((item) => item.toString()).includes(child._id.toString()));
+      if (options?.skip && options?.limit) {
+        return result.slice(options.skip, options.skip + options.limit);
+      }
+      if (options?.limit) {
+        return result.slice(0, options.limit);
+      }
+      if (options?.skip) {
+        return result.slice(options.skip);
+      }
+      return result;
+    }));
+  });
+}
+function createChildrenListDataLoader(path, model, options) {
+  return createDataLoader(async (docs) => {
+    const filter = options?.filter ?? {};
+    const key = path;
+    filter[key] = docs.map((doc) => doc._id);
+    const query = model.find(filter);
+    const data = await query.exec();
+    return cast(docs.map((doc) => {
+      const result = data.filter((child) => child[path]?.toString() === doc._id.toString());
+      if (options?.skip && options?.limit) {
+        return result.slice(options.skip, options.skip + options.limit);
+      }
+      if (options?.limit) {
+        return result.slice(0, options.limit);
+      }
+      if (options?.skip) {
+        return result.slice(options.skip);
+      }
+      return result;
+    }));
+  });
+}
+function createSingleChildDataLoader(path, model) {
+  return createDataLoader(async (docs) => {
+    const data = await model.find({
+      _id: docs.map((doc) => cast(doc[path])).filter((item) => !!item && !["undefined", "null"].includes(item?.toString()))
+    }).exec();
+    const map = new Map(data.map((doc) => [doc.id, doc]));
+    return docs.map((doc) => map.get(doc[path]?.toString() ?? "") ?? null);
+  });
+}
+function createEntitiesReferenceLoader(model) {
+  return createDataLoader(async (ids) => {
+    const docs = await model.find({
+      _id: ids.filter((item) => !!item && !["undefined", "null"].includes(item?.toString()))
+    }).exec();
+    const map = new Map(docs.map((doc) => [doc.id, doc]));
+    return ids.map((id) => map.get(id) ?? null);
+  });
+}
+// src/utils/errors.utils.ts
+import {
+  ApolloServerErrorCode,
+  unwrapResolverError
+} from "@apollo/server/errors";
+import {
+  translate as translateBase
+} from "@nxgt/i18n";
+import { CustomException, ErrorCode } from "@nxgt/shared-exceptions";
+import { MONGO_UTILS, mongoose } from "@nxgt/shared-mongo";
+import { GraphQLError } from "graphql";
+import { kebabCase } from "lodash";
+import { OryUnavailable } from "stx-sdk/ory";
+function createGraphQLError(message, options) {
+  return new GraphQLError(message, options);
+}
+function createFormatError(translate = translateBase, production) {
+  return (formattedError, graphQLError) => {
+    if (production && formattedError.extensions?.stacktrace) {
+      formattedError.extensions.stacktrace = undefined;
+    }
+    const error = unwrapResolverError(graphQLError);
+    if (error instanceof CustomException || error instanceof mongoose.MongooseError) {
+      const exception = error instanceof mongoose.MongooseError ? MONGO_UTILS.castError(error) : error;
+      return {
+        ...formattedError,
+        message: exception.errorCode === ErrorCode.ValidationError ? exception.message : translate(exception.message, exception.options),
+        extensions: {
+          ...formattedError.extensions,
+          code: exception.errorCode,
+          debugMessage: exception.debugMessage
+        }
+      };
+    }
+    if ([
+      ApolloServerErrorCode.GRAPHQL_VALIDATION_FAILED,
+      ApolloServerErrorCode.BAD_REQUEST,
+      ApolloServerErrorCode.BAD_USER_INPUT,
+      ApolloServerErrorCode.GRAPHQL_PARSE_FAILED,
+      ApolloServerErrorCode.OPERATION_RESOLUTION_FAILURE,
+      ApolloServerErrorCode.PERSISTED_QUERY_NOT_FOUND,
+      ApolloServerErrorCode.PERSISTED_QUERY_NOT_SUPPORTED
+    ].includes(formattedError.extensions?.code)) {
+      return {
+        ...formattedError,
+        message: translate(`errors.${kebabCase(formattedError.extensions?.code)}`, {}),
+        extensions: {
+          ...formattedError.extensions,
+          debugMessage: formattedError.message
+        }
+      };
+    }
+    return formattedError;
+  };
+}
+var HTTP_STATUS_BY_CODE = {
+  [ErrorCode.BadRequest]: 400,
+  [ErrorCode.ValidationError]: 400,
+  [ErrorCode.Unauthenticated]: 401,
+  [ErrorCode.Forbidden]: 403,
+  [ErrorCode.NotFound]: 404,
+  [ErrorCode.Conflict]: 409,
+  [ErrorCode.ServiceUnavailable]: 503
+};
+function createMaskError(translate = translateBase) {
+  return (error, message, isDev) => {
+    const original = error instanceof GraphQLError && error.originalError ? error.originalError : error;
+    if (original instanceof OryUnavailable) {
+      return new GraphQLError(`ory: ${original.service} is unavailable`, {
+        extensions: {
+          code: ErrorCode.ServiceUnavailable,
+          http: { status: 503 },
+          debugMessage: original.message
+        }
+      });
+    }
+    if (original instanceof CustomException || original instanceof mongoose.MongooseError) {
+      const exception = original instanceof mongoose.MongooseError ? MONGO_UTILS.castError(original) : original;
+      const status = exception.code;
+      return new GraphQLError(exception.errorCode === ErrorCode.ValidationError ? exception.message : translate(exception.message, exception.options), {
+        extensions: {
+          code: exception.errorCode,
+          ...status ? { http: { status } } : {},
+          ...exception.debugMessage ? { debugMessage: exception.debugMessage } : {}
+        }
+      });
+    }
+    if (error instanceof GraphQLError)
+      return error;
+    return new GraphQLError(message, {
+      extensions: isDev ? { code: ErrorCode.InternalServerError, debugMessage: String(error) } : { code: ErrorCode.InternalServerError }
+    });
+  };
+}
+// src/utils/publish.ts
+import { createRedisEventTarget } from "@graphql-yoga/redis-event-target";
+import { createPubSub } from "graphql-yoga";
+var createYogaPubSub = ({
+  publishClient,
+  subscribeClient
+}) => {
+  const eventTarget = createRedisEventTarget({
+    publishClient,
+    subscribeClient
+  });
+  return createPubSub({ eventTarget });
+};
+// src/utils/sandbox.ts
+import { html } from "hono/html";
+var renderSandbox = ({
+  port = 8080,
+  hostname = "localhost",
+  graphqlEndpoint = "graphql",
+  protocol = "http",
+  title = "Sandbox Explorer"
+}) => html`
+<title>${title}</title>
+<div id="sandbox" style="position:absolute;top:0;right:0;bottom:0;left:0"></div>
+<script src="https://embeddable-sandbox.cdn.apollographql.com/_latest/embeddable-sandbox.umd.production.min.js"></script>
+<script>
+    new window.EmbeddedSandbox({
+        target: "#sandbox",
+        // Pass through your server href if you are embedding on an endpoint.
+        // Otherwise, you can pass whatever endpoint you want Sandbox to start up with here.
+        initialEndpoint: "${protocol}://${hostname}:${port}/${graphqlEndpoint}",
+        handleRequest: (endpointUrl, options) => {
+            return fetch(endpointUrl, {
+                ...options,
+                headers: {
+                    ...options.headers
+                },
+            })
+        },
+        hideCookieToggle: true,
+    });
+    // advanced options: https://www.apollographql.com/docs/studio/explorer/sandbox#embedding-sandbox
+</script>
+
+`;
+// src/utils/schema.utils.ts
+import { join } from "node:path";
+import { buildSubgraphSchema as buildSubgraphSchemaBase } from "@apollo/subgraph";
+import { loadFilesSync } from "@graphql-tools/load-files";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { pruneSchema } from "@graphql-tools/utils";
+import { printSchema } from "graphql";
+var __dirname = "/home/steve/workspace/dev/nxgt-core/packages/shared-graphql/src/utils";
+var SHARED_SCHEMA_PATH = join(__dirname, "./**/*.graphqls");
+function loadTypeDefs(...paths) {
+  const typeDefs = mergeTypeDefs([
+    ...paths.flatMap((path) => loadFilesSync(path, {
+      recursive: true
+    }))
+  ]);
+  return typeDefs;
+}
+function buildSubgraphSchema(modulesOrSdl) {
+  return pruneSchema(buildSubgraphSchemaBase(modulesOrSdl), {
+    skipUnusedTypesPruning: false
+  });
+}
+async function generateSchema(output, ...paths) {
+  await Bun.write(output, printSchema(buildSubgraphSchema(loadTypeDefs(...paths))));
+}
+// src/utils/websocket.ts
+import { createServer } from "node:http";
+import { useServer } from "graphql-ws/use/ws";
+import { WebSocketServer } from "ws";
+function setupYogaWebSocketServer({
+  yoga,
+  context
+}) {
+  const httpServer = createServer(yoga);
+  const wsServer = new WebSocketServer({
+    server: httpServer,
+    path: yoga.graphqlEndpoint
+  });
+  useServer({
+    execute: (args) => args.rootValue.execute(args),
+    subscribe: (args) => args.rootValue.subscribe(args),
+    onSubscribe: async (ctx, _id, params) => {
+      const { schema, execute, subscribe, contextFactory, parse, validate } = yoga.getEnveloped({
+        ...ctx,
+        req: ctx.extra.request,
+        socket: ctx.extra.socket,
+        params
+      });
+      const args = {
+        schema,
+        operationName: params.operationName,
+        document: parse(params.query),
+        variableValues: params.variables,
+        contextValue: await contextFactory(),
+        rootValue: {
+          execute,
+          subscribe
+        }
+      };
+      const errors = validate(args.schema, args.document);
+      if (errors.length)
+        return errors;
+      return args;
+    },
+    context
+  }, wsServer);
+  const startServer = (port) => new Promise((resolve) => httpServer.listen({ port }, resolve));
+  return { yoga, httpServer, startServer };
+}
+// src/utils/ws-context.ts
+async function resolveWsUser(connectionParams, authClient) {
+  const rawToken = connectionParams?.authorization ?? connectionParams?.Authorization;
+  const token = rawToken?.replace("Bearer ", "");
+  const { data } = token ? await authClient.POST("/oauth/introspect", { body: { token } }) : { data: null };
+  const user = data?.active ? { ...data, name: data.sub } : undefined;
+  return { user, token };
+}
+// src/integrations/hono.ts
+function sandboxExpolorer(options) {
+  return createMiddleware(async (ctx) => {
+    return ctx.html(renderSandbox(options));
+  });
+}
+function honoYoga(yoga) {
+  return createMiddleware(async (ctx) => {
+    const response = await yoga.fetch(ctx.req.raw);
+    return response;
+  });
+}
+function createYogaHono(yoga, options) {
+  const app = new Hono;
+  app.use(contextStorage());
+  app.use(languageDetector({
+    order: ["header"],
+    supportedLanguages: ["en", "fr"],
+    fallbackLanguage: "en",
+    caches: []
+  }));
+  app.get("/health", (ctx) => {
+    return ctx.json({ status: "ok" }, 200);
+  });
+  app.get(options?.sandbox?.endpoint || "sandbox", sandboxExpolorer(options?.sandbox || {}));
+  app.use(yoga.graphqlEndpoint, honoYoga(yoga));
+  return app;
+}
+// src/plugins/auth.ts
+function useAuth() {
+  return {
+    onContextBuilding: async ({ context, extendContext }) => {
+      extendContext({
+        user: context.params.extensions?.user,
+        token: context.params.extensions?.token
+      });
+    }
+  };
+}
+// src/plugins/extract-jwt.ts
+import { logger } from "@nxgt/shared-logging";
+var extractJwtPlugin = {
+  async requestDidStart({ request, contextValue }) {
+    logger.info(`[${request.extensions?.subgraphName}] Extracting JWT from request extensions: ${request.extensions?.payload?.sub}`, request.extensions);
+    contextValue.jwt = {
+      payload: request.extensions?.payload
+    };
+  }
+};
+// src/plugins/ory-auth.ts
+import { GraphQLError as GraphQLError2 } from "graphql";
+import {
+  bearerOf,
+  OryUnavailable as OryUnavailable2
+} from "stx-sdk/ory";
+function toPrincipal(ory) {
+  const email = ory.identity?.email;
+  return {
+    sub: ory.subject,
+    uid: ory.subject,
+    name: email ?? ory.clientId ?? ory.subject,
+    username: email,
+    clientId: ory.clientId,
+    scope: ory.scopes.join(" ") || undefined,
+    tokenType: ory.kind,
+    exp: ory.expiresAt ? Math.floor(ory.expiresAt.getTime() / 1000) : undefined,
+    authorities: [],
+    roles: []
+  };
+}
+function oryUnavailableError(error) {
+  return new GraphQLError2(`ory: ${error.service} is unavailable`, {
+    extensions: {
+      code: "SERVICE_UNAVAILABLE",
+      http: { status: 503 },
+      debugMessage: error.message
+    }
+  });
+}
+async function resolveOryPrincipal(ory, headers) {
+  let principal;
+  try {
+    principal = await ory.resolve(headers);
+  } catch (error) {
+    if (error instanceof OryUnavailable2)
+      throw oryUnavailableError(error);
+    throw error;
+  }
+  return {
+    ory: principal,
+    user: principal ? toPrincipal(principal) : undefined,
+    token: bearerOf(headers) ?? undefined
+  };
+}
+function useOryAuth(ory) {
+  return {
+    onContextBuilding: async ({ context, extendContext }) => {
+      extendContext(await resolveOryPrincipal(ory, context.request.headers));
+    }
+  };
+}
+// src/scalars/any/any.scalars.ts
+import { GraphQLScalarType, Kind } from "graphql";
+var ANY_SCALAR = {
+  Any: new GraphQLScalarType({
+    name: "Any",
+    description: "Generic scalar to represent any type",
+    serialize(value) {
+      return value;
+    },
+    parseValue(value) {
+      return value;
+    },
+    parseLiteral(ast, variables) {
+      switch (ast.kind) {
+        case Kind.STRING:
+        case Kind.BOOLEAN:
+          return ast.value;
+        case Kind.INT:
+        case Kind.FLOAT:
+          return parseFloat(ast.value);
+        case Kind.OBJECT:
+          return Object.fromEntries(ast.fields.map((field) => [field.name, field.value]));
+        case Kind.LIST:
+          return ast.values.map((n) => this?.parseLiteral?.(n, variables));
+        case Kind.NULL:
+          return null;
+        case Kind.VARIABLE: {
+          const name = ast.name.value;
+          return variables ? variables[name] : undefined;
+        }
+      }
+    }
+  })
+};
+// src/scalars/custom/custom.scalars.ts
+import {
+  AccountNumberResolver,
+  BigIntResolver,
+  CountryCodeResolver,
+  CountryNameResolver,
+  CuidResolver,
+  CurrencyResolver,
+  DateResolver,
+  DateTimeISOResolver,
+  DurationResolver,
+  EmailAddressResolver,
+  GeoJSONResolver,
+  GUIDResolver,
+  HexadecimalResolver,
+  HexColorCodeResolver,
+  HSLAResolver,
+  HSLResolver,
+  IBANResolver,
+  IPResolver,
+  IPv4Resolver,
+  IPv6Resolver,
+  ISBNResolver,
+  JSONObjectResolver,
+  JSONResolver,
+  JWTResolver,
+  LatitudeResolver,
+  LocaleResolver,
+  LongitudeResolver,
+  LongResolver,
+  MACResolver,
+  NegativeFloatResolver,
+  NegativeIntResolver,
+  NonEmptyStringResolver,
+  NonNegativeFloatResolver,
+  NonNegativeIntResolver,
+  NonPositiveFloatResolver,
+  NonPositiveIntResolver,
+  ObjectIDResolver,
+  PhoneNumberResolver,
+  PortResolver,
+  PositiveFloatResolver,
+  PositiveIntResolver,
+  PostalCodeResolver,
+  RGBAResolver,
+  RGBResolver,
+  SESSNResolver,
+  TimeResolver,
+  TimestampResolver,
+  URLResolver,
+  USCurrencyResolver,
+  UtcOffsetResolver,
+  UUIDResolver,
+  VoidResolver
+} from "graphql-scalars";
+
+// src/scalars/custom/utils.ts
+import { CustomException as CustomException2 } from "@nxgt/shared-exceptions";
+import { logger as logger2 } from "@nxgt/shared-logging";
+import { GraphQLScalarType as GraphQLScalarType2 } from "graphql";
+function createScalarFrom(scalar, {
+  name,
+  description,
+  errorMessage
+}) {
+  const exception = CustomException2.badRequest({
+    message: errorMessage
+  });
+  return new GraphQLScalarType2({
+    ...scalar,
+    name: name ?? scalar.name,
+    description: (description ?? scalar.description)?.replaceAll("`", "'"),
+    serialize(value) {
+      if (!errorMessage) {
+        return scalar.serialize(value);
+      }
+      try {
+        return scalar.serialize(value);
+      } catch (e) {
+        logger2.error(e);
+        throw exception;
+      }
+    },
+    parseValue(value) {
+      if (!errorMessage) {
+        return scalar.parseValue(value);
+      }
+      try {
+        return scalar.parseValue(value);
+      } catch (e) {
+        logger2.error(e);
+        throw exception;
+      }
+    },
+    parseLiteral(ast) {
+      if (!errorMessage) {
+        return scalar.parseLiteral(ast);
+      }
+      try {
+        return scalar.parseLiteral(ast);
+      } catch (e) {
+        logger2.error(e);
+        throw exception;
+      }
+    }
+  });
+}
+
+// src/scalars/custom/custom.scalars.ts
+var CUSTOM_SCALARS = {
+  AccountNumber: createScalarFrom(AccountNumberResolver, {
+    errorMessage: "validation.errors.invalid-account-number"
+  }),
+  BigInt: createScalarFrom(BigIntResolver, {
+    errorMessage: "validation.errors.invalid-big-int"
+  }),
+  CountryCode: createScalarFrom(CountryCodeResolver, {
+    errorMessage: "validation.errors.invalid-country-code"
+  }),
+  CountryName: createScalarFrom(CountryNameResolver, {
+    errorMessage: "validation.errors.invalid-country-name"
+  }),
+  Cuid: createScalarFrom(CuidResolver, {
+    errorMessage: "validation.errors.invalid-cuid"
+  }),
+  CurrencyCode: createScalarFrom(CurrencyResolver, {
+    name: "CurrencyCode",
+    errorMessage: "validation.errors.invalid-currency"
+  }),
+  Date: createScalarFrom(DateResolver, {
+    errorMessage: "validation.errors.invalid-date"
+  }),
+  DateTime: createScalarFrom(DateTimeISOResolver, {
+    name: "DateTime",
+    errorMessage: "validation.errors.invalid-date-time"
+  }),
+  Duration: createScalarFrom(DurationResolver, {
+    errorMessage: "validation.errors.invalid-duration"
+  }),
+  EmailAddress: createScalarFrom(EmailAddressResolver, {
+    errorMessage: "validation.errors.invalid-email-address"
+  }),
+  GeoJSON: createScalarFrom(GeoJSONResolver, {
+    errorMessage: "validation.errors.invalid-geo-json"
+  }),
+  GUID: createScalarFrom(GUIDResolver, {
+    errorMessage: "validation.errors.invalid-guid"
+  }),
+  HexColorCode: createScalarFrom(HexColorCodeResolver, {
+    errorMessage: "validation.errors.invalid-hex-color-code"
+  }),
+  Hexadecimal: createScalarFrom(HexadecimalResolver, {
+    errorMessage: "validation.errors.invalid-hexadecimal"
+  }),
+  HSL: createScalarFrom(HSLResolver, {
+    errorMessage: "validation.errors.invalid-hsl"
+  }),
+  HSLA: createScalarFrom(HSLAResolver, {
+    errorMessage: "validation.errors.invalid-hsla"
+  }),
+  IBAN: createScalarFrom(IBANResolver, {
+    errorMessage: "validation.errors.invalid-iban"
+  }),
+  IP: createScalarFrom(IPResolver, {
+    errorMessage: "validation.errors.invalid-ip"
+  }),
+  IPv4: createScalarFrom(IPv4Resolver, {
+    errorMessage: "validation.errors.invalid-ipv4"
+  }),
+  IPv6: createScalarFrom(IPv6Resolver, {
+    errorMessage: "validation.errors.invalid-ipv6"
+  }),
+  ISBN: createScalarFrom(ISBNResolver, {
+    errorMessage: "validation.errors.invalid-isbn"
+  }),
+  JSON: createScalarFrom(JSONResolver, {
+    errorMessage: "validation.errors.invalid-json"
+  }),
+  JSONObject: createScalarFrom(JSONObjectResolver, {
+    errorMessage: "validation.errors.invalid-json-object"
+  }),
+  JWT: createScalarFrom(JWTResolver, {
+    errorMessage: "validation.errors.invalid-jwt"
+  }),
+  Latitude: createScalarFrom(LatitudeResolver, {
+    errorMessage: "validation.errors.invalid-latitude"
+  }),
+  Locale: createScalarFrom(LocaleResolver, {
+    errorMessage: "validation.errors.invalid-locale"
+  }),
+  Longitude: createScalarFrom(LongitudeResolver, {
+    errorMessage: "validation.errors.invalid-longitude"
+  }),
+  Long: createScalarFrom(LongResolver, {
+    errorMessage: "validation.errors.invalid-long"
+  }),
+  MAC: createScalarFrom(MACResolver, {
+    errorMessage: "validation.errors.invalid-mac"
+  }),
+  NegativeFloat: createScalarFrom(NegativeFloatResolver, {
+    errorMessage: "validation.errors.invalid-negative-float"
+  }),
+  NegativeInt: createScalarFrom(NegativeIntResolver, {
+    errorMessage: "validation.errors.invalid-negative-int"
+  }),
+  NonEmptyString: createScalarFrom(NonEmptyStringResolver, {
+    errorMessage: "validation.errors.invalid-non-empty-string"
+  }),
+  NonNegativeFloat: createScalarFrom(NonNegativeFloatResolver, {
+    errorMessage: "validation.errors.invalid-non-negative-float"
+  }),
+  NonNegativeInt: createScalarFrom(NonNegativeIntResolver, {
+    errorMessage: "validation.errors.invalid-non-negative-int"
+  }),
+  NonPositiveFloat: createScalarFrom(NonPositiveFloatResolver, {
+    errorMessage: "validation.errors.invalid-non-positive-float"
+  }),
+  NonPositiveInt: createScalarFrom(NonPositiveIntResolver, {
+    errorMessage: "validation.errors.invalid-non-positive-int"
+  }),
+  ObjectID: createScalarFrom(ObjectIDResolver, {
+    errorMessage: "validation.errors.invalid-object-id"
+  }),
+  PhoneNumber: createScalarFrom(PhoneNumberResolver, {
+    errorMessage: "validation.errors.invalid-phone-number"
+  }),
+  Port: createScalarFrom(PortResolver, {
+    errorMessage: "validation.errors.invalid-port"
+  }),
+  PositiveFloat: createScalarFrom(PositiveFloatResolver, {
+    errorMessage: "validation.errors.invalid-positive-float"
+  }),
+  PositiveInt: createScalarFrom(PositiveIntResolver, {
+    errorMessage: "validation.errors.invalid-positive-int"
+  }),
+  PostalCode: createScalarFrom(PostalCodeResolver, {
+    errorMessage: "validation.errors.invalid-postal-code"
+  }),
+  RGB: createScalarFrom(RGBResolver, {
+    errorMessage: "validation.errors.invalid-rgb"
+  }),
+  RGBA: createScalarFrom(RGBAResolver, {
+    errorMessage: "validation.errors.invalid-rgba"
+  }),
+  SESSN: createScalarFrom(SESSNResolver, {
+    errorMessage: "validation.errors.invalid-sessn"
+  }),
+  Time: createScalarFrom(TimeResolver, {
+    errorMessage: "validation.errors.invalid-time"
+  }),
+  Timestamp: createScalarFrom(TimestampResolver, {
+    errorMessage: "validation.errors.invalid-timestamp"
+  }),
+  URL: createScalarFrom(URLResolver, {
+    errorMessage: "validation.errors.invalid-url"
+  }),
+  USCurrency: createScalarFrom(USCurrencyResolver, {
+    errorMessage: "validation.errors.invalid-us-currency"
+  }),
+  UTCOffset: createScalarFrom(UtcOffsetResolver, {
+    errorMessage: "validation.errors.invalid-utc-offset"
+  }),
+  UUID: createScalarFrom(UUIDResolver, {
+    errorMessage: "validation.errors.invalid-uuid"
+  }),
+  Void: createScalarFrom(VoidResolver, {
+    errorMessage: "validation.errors.invalid-void"
+  })
+};
+// src/scalars/upload/upload.scalar.ts
+import GraphQLUpload from "graphql-upload/GraphQLUpload.mjs";
+var UPLOAD_SCALAR = {
+  Upload: createScalarFrom(GraphQLUpload, { name: "Upload" })
+};
+// src/scalars/index.ts
+var SCALAR_RESOLVERS = {
+  ...UPLOAD_SCALAR,
+  ...ANY_SCALAR,
+  ...CUSTOM_SCALARS
+};
+// src/shared.ts
+var SHARED_TYPE_DEFS = `
+type Query {
+	_empty: String
+}
+type Mutation {
+	_empty: String
+}
+type Subscription {
+	_empty: String
+}
+
+directive @authenticated on FIELD_DEFINITION | OBJECT | INTERFACE | SCALAR | ENUM
+
+directive @policy(policies: [[String!]!]!) on FIELD_DEFINITION | OBJECT | INTERFACE | SCALAR | ENUM
+
+directive @shareable on OBJECT | FIELD_DEFINITION
+
+directive @link(url: String!, import: [String!]) on SCHEMA
+
+`;
+// src/upload.ts
+import graphqlUploadExpress from "graphql-upload/graphqlUploadExpress.mjs";
+export {
+  DataLoader2 as DataLoader,
+  FEDERATION_DIRECTIVES,
+  SCALARS_MAPPING,
+  SCALAR_RESOLVERS,
+  SHARED_SCHEMA_PATH,
+  SHARED_TYPE_DEFS,
+  buildSubgraphSchema,
+  createChangeResolvers,
+  createChildrenConnectionDataLoader,
+  createChildrenListDataLoader,
+  createConnectionListDataLoader,
+  createDataLoader,
+  createEntitiesReferenceLoader,
+  createFormatError,
+  createGraphQLError,
+  createMaskError,
+  createSimpleListDataLoader,
+  createSingleChildDataLoader,
+  createYogaHono,
+  createYogaPubSub,
+  extractJwtPlugin,
+  generateSchema,
+  graphqlUploadExpress,
+  honoYoga,
+  loadTypeDefs,
+  oryUnavailableError,
+  renderSandbox,
+  resolveOryPrincipal,
+  resolveWsUser,
+  sandboxExpolorer,
+  setupYogaWebSocketServer,
+  toPrincipal,
+  useAuth,
+  useOryAuth
+};
+
+//# debugId=E74E2102AC1DAAFD64756E2164756E21
+//# sourceMappingURL=index.js.map