@manot40/genql-cli 1.0.0

package/dist/runtime/linkTypeMap.ts

@@ -0,0 +1,133 @@
+import type {
+  CompressedType,
+  CompressedTypeMap,
+  LinkedArgMap,
+  LinkedField,
+  LinkedType,
+  LinkedTypeMap,
+} from './types';
+
+export interface PartialLinkedFieldMap {
+  [field: string]: {
+    type: string;
+    args?: LinkedArgMap;
+  };
+}
+
+export const linkTypeMap = (typeMap: CompressedTypeMap<number>): LinkedTypeMap => {
+  const indexToName: Record<number, string> = Object.assign(
+    {},
+    ...Object.keys(typeMap.types).map((k, i) => ({ [i]: k }))
+  );
+
+  let intermediaryTypeMap = Object.assign(
+    {},
+    ...Object.keys(typeMap.types || {}).map((k): Record<string, LinkedType> => {
+      const type: CompressedType = typeMap.types[k]!;
+      const fields = type || {};
+      return {
+        [k]: {
+          name: k,
+          // type scalar properties
+          scalar: Object.keys(fields).filter((f) => {
+            const [type] = fields[f] || [];
+
+            const isScalar = type && typeMap.scalars.includes(type);
+            if (!isScalar) {
+              return false;
+            }
+            const args = fields[f]?.[1];
+            const argTypes = Object.values(args || {})
+              .map((x) => x?.[1])
+              .filter(Boolean);
+
+            const hasRequiredArgs = argTypes.some((str) => str && str.endsWith('!'));
+            if (hasRequiredArgs) {
+              return false;
+            }
+            return true;
+          }),
+          // fields with corresponding `type` and `args`
+          fields: Object.assign(
+            {},
+            ...Object.keys(fields).map((f): PartialLinkedFieldMap => {
+              const [typeIndex, args] = fields[f] || [];
+              if (typeIndex == null) {
+                return {};
+              }
+              return {
+                [f]: {
+                  // replace index with type name
+                  type: indexToName[typeIndex],
+                  args: Object.assign(
+                    {},
+                    ...Object.keys(args || {}).map((k) => {
+                      // if argTypeString == argTypeName, argTypeString is missing, need to readd it
+                      if (!args || !args[k]) {
+                        return;
+                      }
+                      const [argTypeName, argTypeString] = args[k] as any;
+                      return {
+                        [k]: [indexToName[argTypeName], argTypeString || indexToName[argTypeName]],
+                      };
+                    })
+                  ),
+                },
+              };
+            })
+          ),
+        },
+      };
+    })
+  );
+  const res = resolveConcreteTypes(intermediaryTypeMap);
+  return res;
+};
+
+// replace typename with concrete type
+export const resolveConcreteTypes = (linkedTypeMap: LinkedTypeMap) => {
+  Object.keys(linkedTypeMap).forEach((typeNameFromKey) => {
+    const type: LinkedType = linkedTypeMap[typeNameFromKey]!;
+    // type.name = typeNameFromKey
+    if (!type.fields) {
+      return;
+    }
+
+    const fields = type.fields;
+
+    Object.keys(fields).forEach((f) => {
+      const field: LinkedField = fields[f]!;
+
+      if (field.args) {
+        const args = field.args;
+        Object.keys(args).forEach((key) => {
+          const arg = args[key];
+
+          if (arg) {
+            const [typeName] = arg;
+
+            if (typeof typeName === 'string') {
+              if (!linkedTypeMap[typeName]) {
+                linkedTypeMap[typeName] = { name: typeName };
+              }
+
+              arg[0] = linkedTypeMap[typeName]!;
+            }
+          }
+        });
+      }
+
+      const typeName = field.type as LinkedType | string;
+
+      if (typeof typeName === 'string') {
+        if (!linkedTypeMap[typeName]) {
+          linkedTypeMap[typeName] = { name: typeName };
+        }
+
+        field.type = linkedTypeMap[typeName]!;
+      }
+    });
+  });
+
+  return linkedTypeMap;
+};

package/dist/runtime/typeSelection.ts

@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////
+
+// SOME THINGS TO KNOW BEFORE DIVING IN
+/*
+0. DST is the request type, SRC is the response type
+
+1. FieldsSelection uses an object because currently is impossible to make recursive types
+
+2. FieldsSelection is a recursive type that makes a type based on request type and fields
+
+3. HandleObject handles object types
+
+4. Handle__scalar adds all scalar properties excluding non scalar props
+*/
+
+export type FieldsSelection<SRC extends Anify<DST> | undefined, DST> = {
+  scalar: SRC;
+  union: Handle__isUnion<SRC, DST>;
+  object: HandleObject<SRC, DST>;
+  array: SRC extends Nil ? never : SRC extends Array<infer T | null> ? Array<FieldsSelection<T, DST>> : never;
+  __scalar: Handle__scalar<SRC, DST>;
+  never: never;
+}[DST extends Nil
+  ? 'never'
+  : DST extends false | 0
+    ? 'never'
+    : SRC extends Scalar
+      ? 'scalar'
+      : SRC extends any[]
+        ? 'array'
+        : SRC extends { __isUnion?: any }
+          ? 'union'
+          : DST extends { __scalar?: any }
+            ? '__scalar'
+            : DST extends {}
+              ? 'object'
+              : 'never'];
+
+type HandleObject<SRC extends Anify<DST>, DST> = DST extends boolean
+  ? SRC
+  : SRC extends Nil
+    ? never
+    : Pick<
+        {
+          // using keyof SRC to maintain ?: relations of SRC type
+          [Key in keyof SRC]: Key extends keyof DST
+            ? FieldsSelection<SRC[Key], NonNullable<DST[Key]>>
+            : SRC[Key];
+        },
+        Exclude<keyof DST, FieldsToRemove>
+        //   {
+        //       // remove falsy values
+        //       [Key in keyof DST]: DST[Key] extends false | 0 ? never : Key
+        //   }[keyof DST]
+      >;
+
+type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil
+  ? never
+  : Pick<
+      // continue processing fields that are in DST, directly pass SRC type if not in DST
+      {
+        [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], DST[Key]> : SRC[Key];
+      },
+      // remove fields that are not scalars or are not in DST
+      {
+        [Key in keyof SRC]: SRC[Key] extends Nil
+          ? never
+          : Key extends FieldsToRemove
+            ? never
+            : SRC[Key] extends Scalar
+              ? Key
+              : Key extends keyof DST
+                ? Key
+                : never;
+      }[keyof SRC]
+    >;
+
+type Handle__isUnion<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Omit<SRC, FieldsToRemove>; // just return the union type
+
+type Scalar = string | number | Date | boolean | null | undefined;
+
+type Anify<T> = { [P in keyof T]?: any };
+
+type FieldsToRemove = '__isUnion' | '__scalar' | '__name' | '__args';
+
+type Nil = undefined | null;

package/dist/runtime/types.ts

@@ -0,0 +1,64 @@
+export interface ExecutionResult<TData = { [key: string]: any }> {
+  errors?: Array<Error>;
+  data?: TData | null;
+}
+
+export interface ArgMap<keyType = number> {
+  [arg: string]: [keyType, string] | [keyType] | undefined;
+}
+
+export type CompressedField<keyType = number> = [type: keyType, args?: ArgMap<keyType>];
+
+export interface CompressedFieldMap<keyType = number> {
+  [field: string]: CompressedField<keyType> | undefined;
+}
+
+export type CompressedType<keyType = number> = CompressedFieldMap<keyType>;
+
+export interface CompressedTypeMap<keyType = number> {
+  scalars: Array<keyType>;
+  types: {
+    [type: string]: CompressedType<keyType> | undefined;
+  };
+}
+
+// normal types
+export type Field<keyType = number> = {
+  type: keyType;
+  args?: ArgMap<keyType>;
+};
+
+export interface FieldMap<keyType = number> {
+  [field: string]: Field<keyType> | undefined;
+}
+
+export type Type<keyType = number> = FieldMap<keyType>;
+
+export interface TypeMap<keyType = number> {
+  scalars: Array<keyType>;
+  types: {
+    [type: string]: Type<keyType> | undefined;
+  };
+}
+
+export interface LinkedArgMap {
+  [arg: string]: [LinkedType, string] | undefined;
+}
+export interface LinkedField {
+  type: LinkedType;
+  args?: LinkedArgMap;
+}
+
+export interface LinkedFieldMap {
+  [field: string]: LinkedField | undefined;
+}
+
+export interface LinkedType {
+  name: string;
+  fields?: LinkedFieldMap;
+  scalar?: string[];
+}
+
+export interface LinkedTypeMap {
+  [type: string]: LinkedType | undefined;
+}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "type": "module",
+  "name": "@manot40/genql-cli",
+  "author": "Tommaso De Rossi, morse <beats.by.morse@gmail.com>",
+  "license": "MIT",
+  "version": "1.0.0",
+  "homepage": "https://genql.dev",
+  "description": "Generate a TypeScript SDK for any GraphQl API",
+  "keywords": [
+    "genql",
+    "graphql",
+    "sdk",
+    "typescript"
+  ],
+  "repository": {
+    "url": "https://github.com/manot40/genql"
+  },
+  "bin": {
+    "genql": "./cli.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist esm *.tsbuildinfo && tsdown",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@types/common-tags": "^1.8.1",
+    "@types/fs-extra": "^11.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/mkdirp": "^2.0.0",
+    "@types/node": "^18.19.130",
+    "@types/prettier": "^3.0.0",
+    "@types/rimraf": "^4.0.5",
+    "@types/yargs": "^17.0.35",
+    "changelogen": "^0.6.2",
+    "common-tags": "^1.8.2",
+    "jest": "^29.3.1",
+    "prettier": "^3.7.4",
+    "pretty-quick": "^3.1.3",
+    "ts-jest": "^29.4.6",
+    "tsdown": "^0.19.0-beta.3"
+  },
+  "dependencies": {
+    "@graphql-tools/graphql-file-loader": "^8.1.9",
+    "@graphql-tools/load": "^8.1.8",
+    "fs-extra": "^11.3.3",
+    "graphql": "^16.12.0",
+    "kleur": "^4.1.5",
+    "listr2": "^9.0.5",
+    "lodash-es": "^4.17.22",
+    "mkdirp": "^3.0.1",
+    "rimraf": "^6.1.2",
+    "ufo": "^1.6.2",
+    "undici": "^7.18.2",
+    "yargs": "^18.0.0"
+  },
+  "peerDependencies": {
+    "prettier": "3.x"
+  },
+  "jest": {
+    "transform": {
+      ".(js|jsx|ts|tsx)": "@sucrase/jest-plugin"
+    },
+    "roots": [
+      "<rootDir>/src"
+    ],
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ],
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$",
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!**/node_modules/**",
+      "!src/_old/**",
+      "!**/*.case.ts",
+      "!src/testHelpers/**/*.ts"
+    ],
+    "coverageReporters": [
+      "text"
+    ]
+  }
+}