@aexol/axolotl-core 0.0.1

package/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+    "extends": [
+        "../../.eslintrc.json"
+    ]
+}

package/gen.test.ts

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import { resolveFieldType } from './gen.js';
+import { Options } from 'graphql-js-tree';
+import * as assert from 'node:assert';
+
+test('resolveFieldType', (t, done) => {
+  const possibleVariants = {
+    ['Person | undefined']: resolveFieldType('Person', {
+      type: Options.name,
+      name: 'Person',
+    }),
+    ['Person']: resolveFieldType('Person', {
+      type: Options.required,
+      nest: {
+        type: Options.name,
+        name: 'Person',
+      },
+    }),
+    ['Array<Person | undefined> | undefined']: resolveFieldType('Person', {
+      type: Options.array,
+      nest: {
+        type: Options.name,
+        name: 'Person',
+      },
+    }),
+    ['Array<Person | undefined>']: resolveFieldType('Person', {
+      type: Options.required,
+      nest: {
+        type: Options.array,
+        nest: {
+          type: Options.name,
+          name: 'Person',
+        },
+      },
+    }),
+    ['Array<Person>']: resolveFieldType('Person', {
+      type: Options.required,
+      nest: {
+        type: Options.array,
+        nest: {
+          type: Options.required,
+          nest: {
+            type: Options.name,
+            name: 'Person',
+          },
+        },
+      },
+    }),
+  };
+  Object.entries(possibleVariants).forEach(([k, v]) => {
+    assert.equal(k, v);
+  });
+  done();
+});

package/gen.ts

@@ -0,0 +1,103 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { FieldType, Options, Parser, ParserField, TypeDefinition, getTypeName } from 'graphql-js-tree';
+
+const TAB = (n: number) =>
+  new Array(n)
+    .fill(1)
+    .map(() => '  ')
+    .join('');
+
+const toTsType = (t: string) => {
+  if (t === 'String') return 'string';
+  if (t === 'Int') return 'number';
+  if (t === 'Float') return 'number';
+  if (t === 'ID') return 'unknown';
+  if (t === 'Boolean') return 'boolean';
+  return t;
+};
+
+export const resolveFieldType = (
+  name: string,
+  fType: FieldType,
+  fn: (str: string) => string = (x) => x,
+  isRequired = false,
+): string => {
+  if (fType.type === Options.name) {
+    return fn(isRequired ? name : `${name} | undefined`);
+  }
+  if (fType.type === Options.array) {
+    return resolveFieldType(
+      name,
+      fType.nest,
+      isRequired ? (x) => `Array<${fn(x)}>` : (x) => `Array<${fn(x)}> | undefined`,
+      false,
+    );
+  }
+  if (fType.type === Options.required) {
+    return resolveFieldType(name, fType.nest, fn, true);
+  }
+  throw new Error('Invalid field type');
+};
+
+export const resolveField = (f: ParserField): string => {
+  const isNullType = (type: string): string => {
+    return f.type.fieldType.type === Options.required ? `: ${type}` : `?: ${type}`;
+  };
+  return `${TAB(1)}${f.name}${isNullType(resolveFieldType(toTsType(getTypeName(f.type.fieldType)), f.type.fieldType))}`;
+};
+
+const buildArgs = (args: ParserField[]) => {
+  if (args.length === 0) return 'never;';
+  const inputFields = args.map((a) => `${TAB(3)}${resolveField(a)};`);
+  return `{\n${inputFields.join('\n')}\n${TAB(3)}};`;
+};
+
+const buildEnumArgs = (args: ParserField[]) => {
+  if (args.length === 0) return 'never';
+  const inputFields = args.map((a) => `${TAB(1)}${a.name} = "${a.name}"`);
+  return `{\n${inputFields.join(',\n')}\n}`;
+};
+
+const generateModelsString = (fileContent: string) => {
+  const { nodes } = Parser.parse(fileContent);
+
+  const scalars = nodes.filter((n) => n.data.type === TypeDefinition.ScalarTypeDefinition);
+  const scalarsString = scalars.map((s) => `export type ${s.name} = unknown`).join('\n');
+
+  const enums = nodes.filter((n) => n.data.type === TypeDefinition.EnumTypeDefinition);
+  const enumsString = enums.map((s) => `export enum ${s.name} ${buildEnumArgs(s.args)}`).join('\n');
+
+  const inputs = nodes.filter((n) => n.data.type === TypeDefinition.InputObjectTypeDefinition);
+  const inputsString = inputs
+    .map((i) => {
+      const inputFields = i.args.map((a) => `${resolveField(a)};`);
+      return `export interface ${i.name} {\n${inputFields.join('\n')}\n}`;
+    })
+    .join('\n');
+
+  const types = nodes.filter((n) => n.data.type === TypeDefinition.ObjectTypeDefinition);
+  const typesString = types
+    .map((t) => {
+      const typeFields = t.args.map((a) => {
+        return `${TAB(2)}${a.name}: {\n${TAB(3)}args: ${buildArgs(a.args)}\n${TAB(2)}};`;
+      });
+      return `${TAB(1)}['${t.name}']: {\n${typeFields.join('\n')}\n${TAB(1)}};`;
+    })
+    .join('\n');
+
+  const typesFullString = `export type Models = {\n${typesString}\n};\n`;
+
+  return [scalarsString, enumsString, inputsString, typesFullString].filter(Boolean).join('\n\n');
+};
+
+export const generateModels = ({
+  schemaPath = './schema.graphql',
+  modelsPath = './models.ts',
+}: {
+  schemaPath: string;
+  modelsPath: string;
+}) => {
+  const fileContent = readFileSync(schemaPath, 'utf8');
+  const modelsString = generateModelsString(fileContent);
+  writeFileSync(modelsPath, modelsString);
+};

package/index.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { generateModels } from '@/gen.js';
+
+interface CustomHandler<InputType, ArgumentsType = unknown> {
+  (input: InputType, args: ArgumentsType extends { args: infer R } ? R : never): any;
+}
+interface CustomMiddlewareHandler<InputType> {
+  (input: InputType): InputType;
+}
+
+export type ResolversUnknown<InputType> = {
+  [x: string]: {
+    [x: string]: (input: InputType, args?: any) => any | undefined | Promise<any | undefined>;
+  };
+};
+
+type InferAdapterType<ADAPTER extends (passedResolvers: ResolversUnknown<any>, production?: boolean) => any> =
+  Parameters<ADAPTER>[0] extends {
+    [x: string]: {
+      [y: string]: infer R;
+    };
+  }
+    ? R extends (...args: any[]) => any
+      ? Parameters<R>[0]
+      : never
+    : never;
+
+export const AxolotlAdapter =
+  <Inp>() =>
+  <T>(fn: (passedResolvers: ResolversUnknown<Inp>, production?: boolean) => T) =>
+    fn;
+
+export { generateModels };
+
+export const Axolotl =
+  <ADAPTER extends (passedResolvers: ResolversUnknown<any>, production?: boolean) => any>(adapter: ADAPTER) =>
+  <Models>({
+    production,
+    schemaPath,
+    modelsPath,
+  }: {
+    // input is only required for frameworks with external routing
+    schemaPath: string;
+    modelsPath: string;
+    // Instead of controlling developer and production mode by some force envs we allow to control it however you want. Generators don't run on production
+    production?: boolean;
+  }) => {
+    type Inp = InferAdapterType<ADAPTER>;
+    type Resolvers = {
+      [P in keyof Models]?: {
+        [T in keyof Models[P]]?: CustomHandler<Inp, Models[P][T]>;
+      };
+    };
+    type Handler = CustomHandler<Inp>;
+    type MiddlewareHandler = CustomMiddlewareHandler<Inp>;
+
+    const createResolvers = <Z>(k: Z | Resolvers) => k as Z;
+
+    if (!production) {
+      // We need to generate models for Axolotl to work this is called with CLI but also on every dev run to keep things in sync
+      generateModels({ schemaPath, modelsPath });
+    }
+
+    const applyMiddleware = <Z>(
+      r: Z | Resolvers,
+      middlewares: MiddlewareHandler[],
+      k: {
+        [P in keyof Z]?: {
+          [Y in keyof Z[P]]?: true;
+        };
+      },
+    ) => {
+      Object.entries(k).forEach(([typeName, fields]) => {
+        Object.keys(fields as Record<string, true>).forEach((fieldName) => {
+          const oldResolver = (r as Record<string, Record<string, Handler>>)[typeName][fieldName];
+          (r as Record<string, Record<string, Handler>>)[typeName][fieldName] = middlewares.reduce((a, b) => {
+            return (input, args) => {
+              const middlewaredInput = b(input);
+              return a(middlewaredInput, args);
+            };
+          }, oldResolver);
+        });
+      });
+    };
+
+    return {
+      createResolvers,
+      applyMiddleware,
+    };
+  };

package/jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  preset: 'ts-jest',
+  moduleFileExtensions: ['ts', 'tsx', 'js'],
+  moduleNameMapper: {
+    '@/(.*)': ['<rootDir>/$1'],
+  },
+  testMatch: ['<rootDir>/**/*.spec.(ts|tsx)'],
+  watchPathIgnorePatterns: ['node_modules'],
+  watchman: false,
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@aexol/axolotl-core",
+  "version": "0.0.1",
+  "private": false,
+  "main": "./lib/index.js",
+  "author": "Aexol, Artur Czemiel",
+  "type": "module",
+  "scripts": {
+    "build": "tspc",
+    "start": "tspc --watch",
+    "lint": "tspc && eslint \"./src/**/*.{ts,js}\" --quiet --fix"
+  },
+  "dependencies": {
+    "graphql-js-tree": "^1.0.6"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "target": "es2022",
+    "module": "es2022",
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "declaration": true,
+    "incremental": true,
+    "removeComments": true,
+    "noUnusedLocals": true,
+    "strictNullChecks": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "outDir": "./lib",
+    "lib": [
+      "ESNext",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "rootDir": "./",
+    "baseUrl": "./",
+    "composite": true,
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    },
+    "plugins": [
+      {
+        "transform": "typescript-transform-paths"
+      },
+      {
+        "transform": "typescript-transform-paths",
+        "afterDeclarations": true
+      }
+    ]
+  },
+  "exclude": [
+    "lib",
+    "node_modules",
+    "jest.config.js",
+  ]
+}