@ttoss/graphql-api 0.7.5 → 0.7.7

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@ttoss/graphql-api",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "description": "A library for building GraphQL APIs using ttoss ecosystem.",
+  "license": "MIT",
   "author": "ttoss",
   "contributors": [
     "Pedro Arantes <pedro@arantespp.com> (https://arantespp.com)"
@@ -27,8 +28,7 @@
     "ttoss-graphql-api": "./bin/cli.js"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "sideEffects": false,
   "dependencies": {
@@ -42,7 +42,7 @@
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "yargs": "^17.7.2",
-    "@ttoss/ids": "^0.2.11"
+    "@ttoss/ids": "^0.2.13"
   },
   "peerDependencies": {
     "graphql": "^16.6.0"
@@ -52,7 +52,7 @@
     "graphql": "^16.8.1",
     "jest": "^29.7.0",
     "tsup": "^8.3.0",
-    "@ttoss/config": "^1.33.0"
+    "@ttoss/config": "^1.34.1"
   },
   "keywords": [
     "api",

package/src/buildSchema.ts

@@ -1,51 +0,0 @@
-import { type GraphQLSchema } from 'graphql';
-import {
-  type IMiddleware as Middleware,
-  type IMiddlewareGenerator as MiddlewareGenerator,
-  applyMiddleware,
-} from 'graphql-middleware';
-import { type SchemaComposer } from 'graphql-compose';
-
-export type { Middleware, MiddlewareGenerator };
-
-export type BuildSchemaInput<TContext = unknown> = {
-  schemaComposer: SchemaComposer<TContext>;
-  middlewares?: (
-    | Middleware
-    | MiddlewareGenerator<unknown, TContext, unknown>
-  )[];
-};
-
-export const buildSchema = ({
-  schemaComposer,
-  middlewares,
-}: BuildSchemaInput): GraphQLSchema => {
-  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 as MiddlewareGenerator<unknown, unknown, unknown>)
-            .generate
-        ) {
-          return (
-            middleware as MiddlewareGenerator<unknown, unknown, unknown>
-          ).generate(schema);
-        }
-
-        return middleware;
-      })
-    );
-  }
-
-  return schema;
-};

package/src/cli.ts

@@ -1,126 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as typescriptPlugin from '@graphql-codegen/typescript';
-import { codegen } from '@graphql-codegen/core';
-import { hideBin } from 'yargs/helpers';
-import { parse } from 'graphql';
-import { register } from 'ts-node';
-import { register as registerTsPaths } from 'tsconfig-paths';
-import log from 'npmlog';
-import yargs from 'yargs';
-
-const logPrefix = 'graphql-api';
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const tsConfig = require(path.resolve(process.cwd(), 'tsconfig.json'));
-let cleanup = () => {};
-try {
-  const baseUrl = tsConfig?.compilerOptions?.baseUrl;
-  const paths = tsConfig?.compilerOptions?.paths;
-  if ((baseUrl && !paths) || (!baseUrl && paths)) {
-    throw new Error(
-      "tsconfig.json must have 'baseUrl' and 'paths' properties."
-    );
-  }
-  if (baseUrl && paths) {
-    cleanup = registerTsPaths({
-      baseUrl: tsConfig.compilerOptions.baseUrl,
-      paths: tsConfig.compilerOptions.paths,
-    });
-  }
-} catch (error: unknown) {
-  error instanceof Error && log.error(logPrefix, error.message);
-  process.exit(1);
-}
-
-register({
-  transpileOnly: true,
-  compilerOptions: {
-    module: 'NodeNext',
-    moduleResolution: 'NodeNext',
-  },
-});
-
-const buildSchema = async ({ directory }: { directory: string }) => {
-  log.info(logPrefix, 'Building schema...');
-
-  await fs.promises.mkdir('schema', { recursive: true });
-
-  /**
-   * Create schema/types.ts if it doesn't exist. We need to do this because
-   * graphql-codegen will throw an error if the file doesn't exist and the
-   * code import the types from that file.
-   */
-  try {
-    await fs.promises.access('schema/types.ts');
-  } catch {
-    await fs.promises.writeFile('schema/types.ts', '');
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const { schemaComposer } = require(
-    path.resolve(process.cwd(), directory, 'schemaComposer.ts')
-  );
-
-  const sdl = schemaComposer.toSDL();
-
-  /**
-   * https://the-guild.dev/graphql/codegen/docs/advanced/programmatic-usage
-   */
-  const codegenConfig = {
-    documents: [],
-    config: {
-      declarationKind: {
-        type: 'interface',
-        interface: 'interface',
-      },
-      namingConvention: 'keep',
-    },
-    filename: 'schema/types.ts',
-    schema: parse(sdl),
-    plugins: [
-      {
-        typescript: {},
-      },
-    ],
-    pluginMap: {
-      typescript: typescriptPlugin,
-    },
-  };
-
-  await fs.promises.writeFile('schema/schema.graphql', sdl);
-
-  log.info(logPrefix, 'Generating types...');
-
-  const typesOutput = await codegen(codegenConfig);
-
-  const typesOutputIgnore = ['/* eslint-disable */'].join('\n');
-
-  await fs.promises.writeFile(
-    'schema/types.ts',
-    `${typesOutputIgnore}\n${typesOutput}`
-  );
-  cleanup();
-  log.info(logPrefix, 'Schema and types generated!');
-};
-
-yargs(hideBin(process.argv))
-  .command(
-    'build-schema',
-    'fetch the contents of the URL',
-    (yargs) => {
-      return yargs.options({
-        directory: {
-          alias: ['d'],
-          type: 'string',
-          describe: 'Schema composer directory relative to the project root',
-          default: 'src',
-        },
-      });
-    },
-    (argv) => {
-      return buildSchema(argv);
-    }
-  )
-  .demandCommand(1)
-  .strictOptions()
-  .parse();

package/src/composeWithRelay/composeWithRelay.ts

@@ -1,68 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ObjectTypeComposer } from 'graphql-compose';
-import { getNodeFieldConfig } from './nodeFieldConfig';
-import { getNodeInterface } from './nodeInterface';
-import { toGlobalId } from '@ttoss/ids';
-
-// all wrapped typeComposers with Relay, stored in this variable
-// for futher type resolving via NodeInterface.resolveType method
-export const TypeMapForRelayNode: any = {};
-
-export const composeWithRelay = <TContext>(
-  tc: ObjectTypeComposer<any, TContext>
-): ObjectTypeComposer<any, TContext> => {
-  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') {
-    // just skip
-    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;
-};

package/src/composeWithRelay/index.ts

@@ -1,6 +0,0 @@
-import { composeWithRelay } from './composeWithRelay';
-import { schemaComposer } from 'graphql-compose';
-
-composeWithRelay(schemaComposer.Query);
-
-export { composeWithRelay };

package/src/composeWithRelay/nodeFieldConfig.ts

@@ -1,86 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  type InterfaceTypeComposer,
-  type ObjectTypeComposerFieldConfigDefinition,
-  getProjectionFromAST,
-} from 'graphql-compose';
-import { fromGlobalId } from '@ttoss/ids';
-import type { GraphQLResolveInfo } from 'graphql-compose/lib/graphql';
-import type { ObjectTypeComposer, Resolver } from 'graphql-compose';
-
-export type TypeMapForRelayNode<TSource, TContext> = {
-  [typeName: string]: {
-    resolver: Resolver<TSource, TContext>;
-    tc: ObjectTypeComposer<TSource, TContext>;
-  };
-};
-
-// this fieldConfig must be set to RootQuery.node field
-export const getNodeFieldConfig = (
-  typeMapForRelayNode: TypeMapForRelayNode<any, any>,
-  nodeInterface: InterfaceTypeComposer<any, any>
-): ObjectTypeComposerFieldConfigDefinition<any, any> => {
-  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: (
-      source: any,
-      args: { [argName: string]: any },
-      context: any,
-      info: GraphQLResolveInfo
-    ) => {
-      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();
-
-        // set `returnType` for proper work of `getProjectionFromAST`
-        // it will correctly add required fields for `relation` to `projection`
-        let projection;
-        if (info) {
-          projection = getProjectionFromAST({
-            ...info,
-            returnType: graphqlType,
-          });
-        } else {
-          projection = {};
-        }
-
-        // suppose that first argument is argument with id field
-        const idArgName = Object.keys(findById.args)[0];
-        return findById
-          .resolve({
-            source,
-            args: { [idArgName]: args.id }, // eg. mongoose has _id fieldname, so should map
-            context,
-            info,
-            projection,
-          })
-          .then((res: any) => {
-            if (!res) {
-              return res;
-            }
-            res.__nodeType = graphqlType;
-            return res;
-          });
-      }
-
-      return null;
-    },
-  };
-};

package/src/composeWithRelay/nodeInterface.ts

@@ -1,31 +0,0 @@
-import { InterfaceTypeComposer, type SchemaComposer } from 'graphql-compose';
-
-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: any) => {
-    // `payload.__nodeType` was added to payload via nodeFieldConfig.resolve
-    return payload.__nodeType.name ? payload.__nodeType.name : null;
-  },
-});
-
-export const NodeInterface = NodeTC.getType();
-
-export const getNodeInterface = <TContext>(
-  sc: SchemaComposer<TContext>
-): InterfaceTypeComposer<any, TContext> => {
-  if (sc.hasInstance('Node', InterfaceTypeComposer)) {
-    return sc.get('Node') as any;
-  }
-
-  sc.set('Node', NodeTC);
-
-  return NodeTC;
-};

package/src/index.ts

@@ -1,8 +0,0 @@
-export { composeWithRelay } from './composeWithRelay';
-export { default as composeWithConnection } from 'graphql-compose-connection';
-export * from 'graphql-compose';
-export {
-  buildSchema,
-  type BuildSchemaInput,
-  type Middleware,
-} from './buildSchema';

package/src/shield.ts

@@ -1,14 +0,0 @@
-export * from 'graphql-shield';
-/**
- * Export types from graphql-middleware to avoid "The inferred type of 'x'
- * cannot be named without a reference to '.../graphql-middleware/index.d.ts(1,1)'.
- * This is likely not portable. A type annotation is necessary."
- */
-export type {
-  IMiddlewareGenerator,
-  IMiddleware,
-  IMiddlewareFieldMap,
-  IMiddlewareFunction,
-  IMiddlewareGeneratorConstructor,
-  IMiddlewareTypeMap,
-} from 'graphql-middleware';