@ttoss/graphql-api 0.10.2 → 0.10.3

package/dist/index.cjs

@@ -0,0 +1,146 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+Object.defineProperty(exports, Symbol.toStringTag, {
+  value: 'Module'
+});
+let graphql_middleware = require("graphql-middleware");
+let graphql_compose = require("graphql-compose");
+let _ttoss_ids = require("@ttoss/ids");
+let graphql_compose_connection = require("graphql-compose-connection");
+
+//#region src/buildSchema.ts
+const buildSchema = ({
+  schemaComposer,
+  middlewares
+}) => {
+  if (!schemaComposer) throw new Error("No schemaComposer provided");
+  const schema = schemaComposer.buildSchema();
+  if (middlewares) return (0, graphql_middleware.applyMiddleware)(schema, ...middlewares.map(middleware => {
+    /**
+    * https://github.com/dimatill/graphql-middleware/issues/433#issuecomment-1170187160
+    */
+    if (middleware.generate) return middleware.generate(schema);
+    return middleware;
+  }));
+  return schema;
+};
+
+//#endregion
+//#region src/composeWithRelay/nodeFieldConfig.ts
+const getNodeFieldConfig = (typeMapForRelayNode, nodeInterface) => {
+  return {
+    description: "Fetches an object that has globally unique ID among all types",
+    type: nodeInterface,
+    args: {
+      id: {
+        type: "ID!",
+        description: "The globally unique ID among all types"
+      }
+    },
+    resolve: (source, args, context, info) => {
+      if (!args.id || !(typeof args.id === "string")) return null;
+      const {
+        type
+      } = (0, _ttoss_ids.fromGlobalId)(args.id);
+      if (!typeMapForRelayNode[type]) return null;
+      const {
+        tc,
+        resolver: findById
+      } = typeMapForRelayNode[type];
+      if (findById && findById.resolve && tc) {
+        const graphqlType = tc.getType();
+        let projection;
+        if (info) projection = (0, graphql_compose.getProjectionFromAST)({
+          ...info,
+          returnType: graphqlType
+        });else projection = {};
+        const idArgName = Object.keys(findById.args)[0];
+        return findById.resolve({
+          source,
+          args: {
+            [idArgName]: args.id
+          },
+          context,
+          info,
+          projection
+        }).then(res => {
+          if (!res) return res;
+          res.__nodeType = graphqlType;
+          return res;
+        });
+      }
+      return null;
+    }
+  };
+};
+
+//#endregion
+//#region src/composeWithRelay/nodeInterface.ts
+const NodeTC = graphql_compose.InterfaceTypeComposer.createTemp({
+  name: "Node",
+  description: "An object, that can be fetched by the globally unique ID among all types.",
+  fields: {
+    id: {
+      type: "ID!",
+      description: "The globally unique ID among all types."
+    }
+  },
+  resolveType: payload => {
+    return payload.__nodeType.name ? payload.__nodeType.name : null;
+  }
+});
+const NodeInterface = NodeTC.getType();
+const getNodeInterface = sc => {
+  if (sc.hasInstance("Node", graphql_compose.InterfaceTypeComposer)) return sc.get("Node");
+  sc.set("Node", NodeTC);
+  return NodeTC;
+};
+
+//#endregion
+//#region src/composeWithRelay/composeWithRelay.ts
+const TypeMapForRelayNode = {};
+const composeWithRelay = tc => {
+  if (!(tc instanceof graphql_compose.ObjectTypeComposer)) throw new Error("You should provide ObjectTypeComposer instance to composeWithRelay method");
+  const nodeInterface = getNodeInterface(tc.schemaComposer);
+  const nodeFieldConfig = getNodeFieldConfig(TypeMapForRelayNode, nodeInterface);
+  if (tc.getTypeName() === "Query" || tc.getTypeName() === "RootQuery") {
+    tc.setField("node", nodeFieldConfig);
+    return tc;
+  }
+  if (tc.getTypeName() === "Mutation" || tc.getTypeName() === "RootMutation") return tc;
+  if (!tc.hasRecordIdFn()) throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) should have recordIdFn. This function returns ID from provided object.`);
+  const findById = tc.getResolver("findById");
+  if (!findById) throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) provided to composeWithRelay should have findById resolver.`);
+  TypeMapForRelayNode[tc.getTypeName()] = {
+    resolver: findById,
+    tc
+  };
+  tc.addFields({
+    id: {
+      type: "ID!",
+      description: "The globally unique ID among all types",
+      resolve: source => {
+        return (0, _ttoss_ids.toGlobalId)(tc.getTypeName(), tc.getRecordId(source).toString());
+      }
+    }
+  });
+  tc.addInterface(nodeInterface);
+  return tc;
+};
+
+//#endregion
+exports.buildSchema = buildSchema;
+Object.defineProperty(exports, 'composeWithConnection', {
+  enumerable: true,
+  get: function () {
+    return graphql_compose_connection.composeWithConnection;
+  }
+});
+exports.composeWithRelay = composeWithRelay;
+Object.keys(graphql_compose).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () {
+      return graphql_compose[k];
+    }
+  });
+});

package/dist/index.d.cts

@@ -1,18 +1,24 @@
-import { GraphQLSchema } from 'graphql';
-import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
-export * from 'graphql-compose';
-import { IMiddleware, IMiddlewareGenerator } from 'graphql-middleware';
-export { IMiddleware as Middleware } from 'graphql-middleware';
-export { composeWithConnection } from 'graphql-compose-connection';
 
+import { GraphQLSchema } from "graphql";
+import { ObjectTypeComposer, SchemaComposer } from "graphql-compose";
+import { IMiddleware as Middleware, IMiddlewareGenerator as MiddlewareGenerator } from "graphql-middleware";
+import { composeWithConnection } from "graphql-compose-connection";
+export * from "graphql-compose";
+
+//#region src/buildSchema.d.ts
 type BuildSchemaInput<TContext = unknown> = {
-    schemaComposer: SchemaComposer<TContext>;
-    middlewares?: (IMiddleware | IMiddlewareGenerator<unknown, TContext, unknown>)[];
+  schemaComposer: SchemaComposer<TContext>;
+  middlewares?: (Middleware | MiddlewareGenerator<unknown, TContext, unknown>)[];
 };
-declare const buildSchema: ({ schemaComposer, middlewares, }: BuildSchemaInput) => GraphQLSchema;
-
+declare const buildSchema: ({
+  schemaComposer,
+  middlewares
+}: BuildSchemaInput) => GraphQLSchema;
+//#endregion
+//#region src/composeWithRelay/composeWithRelay.d.ts
 declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>) => ObjectTypeComposer<any, TContext>;
-
+//#endregion
+//#region src/index.d.ts
 /**
  * Standard connection arguments used by resolvers created with `composeWithConnection`.
  *
@@ -34,14 +40,14 @@ declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>
  * ```
  */
 type ConnectionArgs<TFilter = unknown, TSort = unknown> = {
-    first?: number | null;
-    after?: string | null;
-    last?: number | null;
-    before?: string | null;
-    limit?: number | null;
-    skip?: number | null;
-    sort?: TSort;
-    filter?: TFilter | null;
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  limit?: number | null;
+  skip?: number | null;
+  sort?: TSort;
+  filter?: TFilter | null;
 };
-
-export { type BuildSchemaInput, type ConnectionArgs, buildSchema, composeWithRelay };
+//#endregion
+export { type BuildSchemaInput, ConnectionArgs, type Middleware, buildSchema, composeWithConnection, composeWithRelay };

package/dist/index.d.mts

@@ -0,0 +1,53 @@
+
+import { IMiddleware as Middleware, IMiddlewareGenerator as MiddlewareGenerator } from "graphql-middleware";
+import { ObjectTypeComposer, SchemaComposer } from "graphql-compose";
+import { composeWithConnection } from "graphql-compose-connection";
+import { GraphQLSchema } from "graphql";
+export * from "graphql-compose";
+
+//#region src/buildSchema.d.ts
+type BuildSchemaInput<TContext = unknown> = {
+  schemaComposer: SchemaComposer<TContext>;
+  middlewares?: (Middleware | MiddlewareGenerator<unknown, TContext, unknown>)[];
+};
+declare const buildSchema: ({
+  schemaComposer,
+  middlewares
+}: BuildSchemaInput) => GraphQLSchema;
+//#endregion
+//#region src/composeWithRelay/composeWithRelay.d.ts
+declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>) => ObjectTypeComposer<any, TContext>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Standard connection arguments used by resolvers created with `composeWithConnection`.
+ *
+ * @typeParam TFilter - Shape of the connection-specific filter object. Defaults to `unknown`.
+ * @typeParam TSort   - Shape of the sort value. Defaults to `unknown`.
+ *
+ * @example
+ * ```ts
+ * import { type ConnectionArgs, type ResolverResolveParams } from '@ttoss/graphql-api';
+ *
+ * type NotificationFilter = { isRead?: boolean | null };
+ *
+ * NotificationTC.addResolver({
+ *   name: 'findMany',
+ *   resolve: async ({ args }: ResolverResolveParams<unknown, Context, ConnectionArgs<NotificationFilter>>) => {
+ *     return findMany({ first: args.first, after: args.after, filter: args.filter });
+ *   },
+ * });
+ * ```
+ */
+type ConnectionArgs<TFilter = unknown, TSort = unknown> = {
+  first?: number | null;
+  after?: string | null;
+  last?: number | null;
+  before?: string | null;
+  limit?: number | null;
+  skip?: number | null;
+  sort?: TSort;
+  filter?: TFilter | null;
+};
+//#endregion
+export { type BuildSchemaInput, ConnectionArgs, type Middleware, buildSchema, composeWithConnection, composeWithRelay };

package/dist/index.mjs

@@ -0,0 +1,129 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+import { applyMiddleware } from "graphql-middleware";
+import { InterfaceTypeComposer, ObjectTypeComposer, getProjectionFromAST } from "graphql-compose";
+import { fromGlobalId, toGlobalId } from "@ttoss/ids";
+import { composeWithConnection } from "graphql-compose-connection";
+export * from "graphql-compose";
+
+//#region src/buildSchema.ts
+const buildSchema = ({
+  schemaComposer,
+  middlewares
+}) => {
+  if (!schemaComposer) throw new Error("No schemaComposer provided");
+  const schema = schemaComposer.buildSchema();
+  if (middlewares) return applyMiddleware(schema, ...middlewares.map(middleware => {
+    /**
+    * https://github.com/dimatill/graphql-middleware/issues/433#issuecomment-1170187160
+    */
+    if (middleware.generate) return middleware.generate(schema);
+    return middleware;
+  }));
+  return schema;
+};
+
+//#endregion
+//#region src/composeWithRelay/nodeFieldConfig.ts
+const getNodeFieldConfig = (typeMapForRelayNode, nodeInterface) => {
+  return {
+    description: "Fetches an object that has globally unique ID among all types",
+    type: nodeInterface,
+    args: {
+      id: {
+        type: "ID!",
+        description: "The globally unique ID among all types"
+      }
+    },
+    resolve: (source, args, context, info) => {
+      if (!args.id || !(typeof args.id === "string")) return null;
+      const {
+        type
+      } = fromGlobalId(args.id);
+      if (!typeMapForRelayNode[type]) return null;
+      const {
+        tc,
+        resolver: findById
+      } = typeMapForRelayNode[type];
+      if (findById && findById.resolve && tc) {
+        const graphqlType = tc.getType();
+        let projection;
+        if (info) projection = getProjectionFromAST({
+          ...info,
+          returnType: graphqlType
+        });else projection = {};
+        const idArgName = Object.keys(findById.args)[0];
+        return findById.resolve({
+          source,
+          args: {
+            [idArgName]: args.id
+          },
+          context,
+          info,
+          projection
+        }).then(res => {
+          if (!res) return res;
+          res.__nodeType = graphqlType;
+          return res;
+        });
+      }
+      return null;
+    }
+  };
+};
+
+//#endregion
+//#region src/composeWithRelay/nodeInterface.ts
+const NodeTC = InterfaceTypeComposer.createTemp({
+  name: "Node",
+  description: "An object, that can be fetched by the globally unique ID among all types.",
+  fields: {
+    id: {
+      type: "ID!",
+      description: "The globally unique ID among all types."
+    }
+  },
+  resolveType: payload => {
+    return payload.__nodeType.name ? payload.__nodeType.name : null;
+  }
+});
+const NodeInterface = NodeTC.getType();
+const getNodeInterface = sc => {
+  if (sc.hasInstance("Node", InterfaceTypeComposer)) return sc.get("Node");
+  sc.set("Node", NodeTC);
+  return NodeTC;
+};
+
+//#endregion
+//#region src/composeWithRelay/composeWithRelay.ts
+const TypeMapForRelayNode = {};
+const composeWithRelay = tc => {
+  if (!(tc instanceof ObjectTypeComposer)) throw new Error("You should provide ObjectTypeComposer instance to composeWithRelay method");
+  const nodeInterface = getNodeInterface(tc.schemaComposer);
+  const nodeFieldConfig = getNodeFieldConfig(TypeMapForRelayNode, nodeInterface);
+  if (tc.getTypeName() === "Query" || tc.getTypeName() === "RootQuery") {
+    tc.setField("node", nodeFieldConfig);
+    return tc;
+  }
+  if (tc.getTypeName() === "Mutation" || tc.getTypeName() === "RootMutation") return tc;
+  if (!tc.hasRecordIdFn()) throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) should have recordIdFn. This function returns ID from provided object.`);
+  const findById = tc.getResolver("findById");
+  if (!findById) throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) provided to composeWithRelay should have findById resolver.`);
+  TypeMapForRelayNode[tc.getTypeName()] = {
+    resolver: findById,
+    tc
+  };
+  tc.addFields({
+    id: {
+      type: "ID!",
+      description: "The globally unique ID among all types",
+      resolve: source => {
+        return toGlobalId(tc.getTypeName(), tc.getRecordId(source).toString());
+      }
+    }
+  });
+  tc.addInterface(nodeInterface);
+  return tc;
+};
+
+//#endregion
+export { buildSchema, composeWithConnection, composeWithRelay };

package/dist/shield.cjs

@@ -0,0 +1,10 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+var graphql_shield = require("graphql-shield");
+Object.keys(graphql_shield).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () {
+      return graphql_shield[k];
+    }
+  });
+});

package/dist/shield.d.cts

@@ -1,2 +1,4 @@
-export * from 'graphql-shield';
-export { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap } from 'graphql-middleware';
+
+import { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap } from "graphql-middleware";
+export * from "graphql-shield";
+export type { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap };

package/dist/shield.d.mts

@@ -0,0 +1,4 @@
+
+import { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap } from "graphql-middleware";
+export * from "graphql-shield";
+export type { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap };

package/dist/{esm/shield.js → shield.mjs}

@@ -1,4 +1,3 @@
 /** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-
-// src/shield.ts
-export * from "graphql-shield";
+export * from "graphql-shield";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/graphql-api",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "A library for building GraphQL APIs using ttoss ecosystem.",
   "keywords": [
     "api",
@@ -39,13 +39,13 @@
     "graphql-middleware": "^6.1.35",
     "graphql-shield": "^7.6.5",
     "npmlog": "^7.0.1",
-    "@ttoss/ids": "^0.4.12"
+    "@ttoss/ids": "^0.4.13"
   },
   "devDependencies": {
     "graphql": "^16.11.0",
     "jest": "^30.3.0",
-    "tsup": "^8.5.1",
-    "@ttoss/config": "^1.37.12"
+    "tsdown": "^0.22.0",
+    "@ttoss/config": "^1.37.13"
   },
   "peerDependencies": {
     "graphql": "^16.6.0"
@@ -55,7 +55,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "test": "jest --projects tests/unit"
   }
 }

package/dist/esm/index.js

@@ -1,166 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-  value,
-  configurable: true
-});
-
-// src/buildSchema.ts
-import { applyMiddleware } from "graphql-middleware";
-var buildSchema = /* @__PURE__ */__name(({
-  schemaComposer: schemaComposer2,
-  middlewares
-}) => {
-  if (!schemaComposer2) {
-    throw new Error("No schemaComposer provided");
-  }
-  const schema = schemaComposer2.buildSchema();
-  if (middlewares) {
-    return applyMiddleware(schema, ...middlewares.map(middleware => {
-      if (middleware.generate) {
-        return middleware.generate(schema);
-      }
-      return middleware;
-    }));
-  }
-  return schema;
-}, "buildSchema");
-
-// src/composeWithRelay/index.ts
-import { schemaComposer } from "graphql-compose";
-
-// src/composeWithRelay/composeWithRelay.ts
-import { toGlobalId } from "@ttoss/ids";
-import { ObjectTypeComposer } from "graphql-compose";
-
-// src/composeWithRelay/nodeFieldConfig.ts
-import { fromGlobalId } from "@ttoss/ids";
-import { getProjectionFromAST } from "graphql-compose";
-var getNodeFieldConfig = /* @__PURE__ */__name((typeMapForRelayNode, nodeInterface) => {
-  return {
-    description: "Fetches an object that has globally unique ID among all types",
-    type: nodeInterface,
-    args: {
-      id: {
-        type: "ID!",
-        description: "The globally unique ID among all types"
-      }
-    },
-    // eslint-disable-next-line max-params
-    resolve: /* @__PURE__ */__name((source, args, context, info) => {
-      if (!args.id || !(typeof args.id === "string")) {
-        return null;
-      }
-      const {
-        type
-      } = fromGlobalId(args.id);
-      if (!typeMapForRelayNode[type]) {
-        return null;
-      }
-      const {
-        tc,
-        resolver: findById
-      } = typeMapForRelayNode[type];
-      if (findById && findById.resolve && tc) {
-        const graphqlType = tc.getType();
-        let projection;
-        if (info) {
-          projection = getProjectionFromAST({
-            ...info,
-            returnType: graphqlType
-          });
-        } else {
-          projection = {};
-        }
-        const idArgName = Object.keys(findById.args)[0];
-        return findById.resolve({
-          source,
-          args: {
-            [idArgName]: args.id
-          },
-          context,
-          info,
-          projection
-        }).then(res => {
-          if (!res) {
-            return res;
-          }
-          res.__nodeType = graphqlType;
-          return res;
-        });
-      }
-      return null;
-    }, "resolve")
-  };
-}, "getNodeFieldConfig");
-
-// src/composeWithRelay/nodeInterface.ts
-import { InterfaceTypeComposer } from "graphql-compose";
-var NodeTC = InterfaceTypeComposer.createTemp({
-  name: "Node",
-  description: "An object, that can be fetched by the globally unique ID among all types.",
-  fields: {
-    id: {
-      type: "ID!",
-      description: "The globally unique ID among all types."
-    }
-  },
-  resolveType: /* @__PURE__ */__name(payload => {
-    return payload.__nodeType.name ? payload.__nodeType.name : null;
-  }, "resolveType")
-});
-var NodeInterface = NodeTC.getType();
-var getNodeInterface = /* @__PURE__ */__name(sc => {
-  if (sc.hasInstance("Node", InterfaceTypeComposer)) {
-    return sc.get("Node");
-  }
-  sc.set("Node", NodeTC);
-  return NodeTC;
-}, "getNodeInterface");
-
-// src/composeWithRelay/composeWithRelay.ts
-var TypeMapForRelayNode = {};
-var composeWithRelay = /* @__PURE__ */__name(tc => {
-  if (!(tc instanceof ObjectTypeComposer)) {
-    throw new Error("You should provide ObjectTypeComposer instance to composeWithRelay method");
-  }
-  const nodeInterface = getNodeInterface(tc.schemaComposer);
-  const nodeFieldConfig = getNodeFieldConfig(TypeMapForRelayNode, nodeInterface);
-  if (tc.getTypeName() === "Query" || tc.getTypeName() === "RootQuery") {
-    tc.setField("node", nodeFieldConfig);
-    return tc;
-  }
-  if (tc.getTypeName() === "Mutation" || tc.getTypeName() === "RootMutation") {
-    return tc;
-  }
-  if (!tc.hasRecordIdFn()) {
-    throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) should have recordIdFn. This function returns ID from provided object.`);
-  }
-  const findById = tc.getResolver("findById");
-  if (!findById) {
-    throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) provided to composeWithRelay should have findById resolver.`);
-  }
-  TypeMapForRelayNode[tc.getTypeName()] = {
-    resolver: findById,
-    tc
-  };
-  tc.addFields({
-    id: {
-      type: "ID!",
-      description: "The globally unique ID among all types",
-      resolve: /* @__PURE__ */__name(source => {
-        return toGlobalId(tc.getTypeName(), tc.getRecordId(source).toString());
-      }, "resolve")
-    }
-  });
-  tc.addInterface(nodeInterface);
-  return tc;
-}, "composeWithRelay");
-
-// src/composeWithRelay/index.ts
-composeWithRelay(schemaComposer.Query);
-
-// src/index.ts
-export * from "graphql-compose";
-import { composeWithConnection } from "graphql-compose-connection";
-export { buildSchema, composeWithConnection, composeWithRelay };

package/dist/index.d.ts

@@ -1,47 +0,0 @@
-import { GraphQLSchema } from 'graphql';
-import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
-export * from 'graphql-compose';
-import { IMiddleware, IMiddlewareGenerator } from 'graphql-middleware';
-export { IMiddleware as Middleware } from 'graphql-middleware';
-export { composeWithConnection } from 'graphql-compose-connection';
-
-type BuildSchemaInput<TContext = unknown> = {
-    schemaComposer: SchemaComposer<TContext>;
-    middlewares?: (IMiddleware | IMiddlewareGenerator<unknown, TContext, unknown>)[];
-};
-declare const buildSchema: ({ schemaComposer, middlewares, }: BuildSchemaInput) => GraphQLSchema;
-
-declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>) => ObjectTypeComposer<any, TContext>;
-
-/**
- * Standard connection arguments used by resolvers created with `composeWithConnection`.
- *
- * @typeParam TFilter - Shape of the connection-specific filter object. Defaults to `unknown`.
- * @typeParam TSort   - Shape of the sort value. Defaults to `unknown`.
- *
- * @example
- * ```ts
- * import { type ConnectionArgs, type ResolverResolveParams } from '@ttoss/graphql-api';
- *
- * type NotificationFilter = { isRead?: boolean | null };
- *
- * NotificationTC.addResolver({
- *   name: 'findMany',
- *   resolve: async ({ args }: ResolverResolveParams<unknown, Context, ConnectionArgs<NotificationFilter>>) => {
- *     return findMany({ first: args.first, after: args.after, filter: args.filter });
- *   },
- * });
- * ```
- */
-type ConnectionArgs<TFilter = unknown, TSort = unknown> = {
-    first?: number | null;
-    after?: string | null;
-    last?: number | null;
-    before?: string | null;
-    limit?: number | null;
-    skip?: number | null;
-    sort?: TSort;
-    filter?: TFilter | null;
-};
-
-export { type BuildSchemaInput, type ConnectionArgs, buildSchema, composeWithRelay };

package/dist/index.js

@@ -1,205 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-"use strict";
-
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", {
-  value,
-  configurable: true
-});
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  buildSchema: () => buildSchema,
-  composeWithConnection: () => import_graphql_compose_connection.composeWithConnection,
-  composeWithRelay: () => composeWithRelay
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/buildSchema.ts
-var import_graphql_middleware = require("graphql-middleware");
-var buildSchema = /* @__PURE__ */__name(({
-  schemaComposer: schemaComposer2,
-  middlewares
-}) => {
-  if (!schemaComposer2) {
-    throw new Error("No schemaComposer provided");
-  }
-  const schema = schemaComposer2.buildSchema();
-  if (middlewares) {
-    return (0, import_graphql_middleware.applyMiddleware)(schema, ...middlewares.map(middleware => {
-      if (middleware.generate) {
-        return middleware.generate(schema);
-      }
-      return middleware;
-    }));
-  }
-  return schema;
-}, "buildSchema");
-
-// src/composeWithRelay/index.ts
-var import_graphql_compose4 = require("graphql-compose");
-
-// src/composeWithRelay/composeWithRelay.ts
-var import_ids2 = require("@ttoss/ids");
-var import_graphql_compose3 = require("graphql-compose");
-
-// src/composeWithRelay/nodeFieldConfig.ts
-var import_ids = require("@ttoss/ids");
-var import_graphql_compose = require("graphql-compose");
-var getNodeFieldConfig = /* @__PURE__ */__name((typeMapForRelayNode, nodeInterface) => {
-  return {
-    description: "Fetches an object that has globally unique ID among all types",
-    type: nodeInterface,
-    args: {
-      id: {
-        type: "ID!",
-        description: "The globally unique ID among all types"
-      }
-    },
-    // eslint-disable-next-line max-params
-    resolve: /* @__PURE__ */__name((source, args, context, info) => {
-      if (!args.id || !(typeof args.id === "string")) {
-        return null;
-      }
-      const {
-        type
-      } = (0, import_ids.fromGlobalId)(args.id);
-      if (!typeMapForRelayNode[type]) {
-        return null;
-      }
-      const {
-        tc,
-        resolver: findById
-      } = typeMapForRelayNode[type];
-      if (findById && findById.resolve && tc) {
-        const graphqlType = tc.getType();
-        let projection;
-        if (info) {
-          projection = (0, import_graphql_compose.getProjectionFromAST)({
-            ...info,
-            returnType: graphqlType
-          });
-        } else {
-          projection = {};
-        }
-        const idArgName = Object.keys(findById.args)[0];
-        return findById.resolve({
-          source,
-          args: {
-            [idArgName]: args.id
-          },
-          context,
-          info,
-          projection
-        }).then(res => {
-          if (!res) {
-            return res;
-          }
-          res.__nodeType = graphqlType;
-          return res;
-        });
-      }
-      return null;
-    }, "resolve")
-  };
-}, "getNodeFieldConfig");
-
-// src/composeWithRelay/nodeInterface.ts
-var import_graphql_compose2 = require("graphql-compose");
-var NodeTC = import_graphql_compose2.InterfaceTypeComposer.createTemp({
-  name: "Node",
-  description: "An object, that can be fetched by the globally unique ID among all types.",
-  fields: {
-    id: {
-      type: "ID!",
-      description: "The globally unique ID among all types."
-    }
-  },
-  resolveType: /* @__PURE__ */__name(payload => {
-    return payload.__nodeType.name ? payload.__nodeType.name : null;
-  }, "resolveType")
-});
-var NodeInterface = NodeTC.getType();
-var getNodeInterface = /* @__PURE__ */__name(sc => {
-  if (sc.hasInstance("Node", import_graphql_compose2.InterfaceTypeComposer)) {
-    return sc.get("Node");
-  }
-  sc.set("Node", NodeTC);
-  return NodeTC;
-}, "getNodeInterface");
-
-// src/composeWithRelay/composeWithRelay.ts
-var TypeMapForRelayNode = {};
-var composeWithRelay = /* @__PURE__ */__name(tc => {
-  if (!(tc instanceof import_graphql_compose3.ObjectTypeComposer)) {
-    throw new Error("You should provide ObjectTypeComposer instance to composeWithRelay method");
-  }
-  const nodeInterface = getNodeInterface(tc.schemaComposer);
-  const nodeFieldConfig = getNodeFieldConfig(TypeMapForRelayNode, nodeInterface);
-  if (tc.getTypeName() === "Query" || tc.getTypeName() === "RootQuery") {
-    tc.setField("node", nodeFieldConfig);
-    return tc;
-  }
-  if (tc.getTypeName() === "Mutation" || tc.getTypeName() === "RootMutation") {
-    return tc;
-  }
-  if (!tc.hasRecordIdFn()) {
-    throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) should have recordIdFn. This function returns ID from provided object.`);
-  }
-  const findById = tc.getResolver("findById");
-  if (!findById) {
-    throw new Error(`ObjectTypeComposer(${tc.getTypeName()}) provided to composeWithRelay should have findById resolver.`);
-  }
-  TypeMapForRelayNode[tc.getTypeName()] = {
-    resolver: findById,
-    tc
-  };
-  tc.addFields({
-    id: {
-      type: "ID!",
-      description: "The globally unique ID among all types",
-      resolve: /* @__PURE__ */__name(source => {
-        return (0, import_ids2.toGlobalId)(tc.getTypeName(), tc.getRecordId(source).toString());
-      }, "resolve")
-    }
-  });
-  tc.addInterface(nodeInterface);
-  return tc;
-}, "composeWithRelay");
-
-// src/composeWithRelay/index.ts
-composeWithRelay(import_graphql_compose4.schemaComposer.Query);
-
-// src/index.ts
-__reExport(index_exports, require("graphql-compose"), module.exports);
-var import_graphql_compose_connection = require("graphql-compose-connection");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildSchema,
-  composeWithConnection,
-  composeWithRelay,
-  ...require("graphql-compose")
-});

package/dist/shield.d.ts

@@ -1,2 +0,0 @@
-export * from 'graphql-shield';
-export { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap } from 'graphql-middleware';

package/dist/shield.js

@@ -1,29 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-"use strict";
-
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-
-// src/shield.ts
-var shield_exports = {};
-module.exports = __toCommonJS(shield_exports);
-__reExport(shield_exports, require("graphql-shield"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("graphql-shield")
-});