@pothos/plugin-drizzle 0.0.1

package/lib/src/utils/usage.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    extendWithUsage: function() {
+        return extendWithUsage;
+    },
+    isUsed: function() {
+        return isUsed;
+    },
+    usageSymbol: function() {
+        return usageSymbol;
+    },
+    wrapWithUsageCheck: function() {
+        return wrapWithUsageCheck;
+    }
+});
+const usageSymbol = Symbol.for('Pothos.isUsed');
+function wrapWithUsageCheck(obj) {
+    const result = {};
+    let used = true;
+    Object.defineProperty(result, usageSymbol, {
+        get () {
+            return used;
+        },
+        set (value) {
+            used = value;
+        },
+        enumerable: false
+    });
+    for (const key of Object.keys(obj)){
+        // only set to false if the object has keys
+        used = false;
+        Object.defineProperty(result, key, {
+            enumerable: true,
+            configurable: true,
+            // eslint-disable-next-line @typescript-eslint/no-loop-func
+            get () {
+                used = true;
+                return obj[key];
+            }
+        });
+    }
+    return result;
+}
+function isUsed(obj) {
+    return !(usageSymbol in obj) || obj[usageSymbol];
+}
+function extendWithUsage(original, extension) {
+    if (!(usageSymbol in original)) {
+        return {
+            ...original,
+            ...extension
+        };
+    }
+    const result = {
+        ...extension
+    };
+    for (const key of [
+        usageSymbol,
+        ...Object.keys(original)
+    ]){
+        if (key in result) {
+            continue;
+        }
+        Object.defineProperty(result, key, {
+            enumerable: key !== usageSymbol,
+            configurable: key !== usageSymbol,
+            get () {
+                return original[key];
+            }
+        });
+    }
+    return result;
+}
+
+//# sourceMappingURL=usage.js.map

package/lib/src/utils/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/usage.ts"],"names":["extendWithUsage","isUsed","usageSymbol","wrapWithUsageCheck","Symbol","for","obj","result","used","Object","defineProperty","get","set","value","enumerable","key","keys","configurable","original","extension"],"mappings":";;;;;;;;;;;IAqCgBA,eAAe;eAAfA;;IAJAC,MAAM;eAANA;;IAjCHC,WAAW;eAAXA;;IAEGC,kBAAkB;eAAlBA;;;AAFT,MAAMD,cAAcE,OAAOC,GAAG,CAAC;AAE/B,SAASF,mBAAqCG,GAAM;IACzD,MAAMC,SAAS,CAAC;IAChB,IAAIC,OAAO;IAEXC,OAAOC,cAAc,CAACH,QAAQL,aAAa;QACzCS;YACE,OAAOH;QACT;QACAI,KAAIC,KAAc;YAChBL,OAAOK;QACT;QACAC,YAAY;IACd;IAEA,KAAK,MAAMC,OAAON,OAAOO,IAAI,CAACV,KAAM;QAClC,2CAA2C;QAC3CE,OAAO;QACPC,OAAOC,cAAc,CAACH,QAAQQ,KAAK;YACjCD,YAAY;YACZG,cAAc;YACd,2DAA2D;YAC3DN;gBACEH,OAAO;gBACP,OAAOF,GAAG,CAACS,IAAe;YAC5B;QACF;IACF;IAEA,OAAOR;AACT;AAEO,SAASN,OAAOK,GAAW;IAChC,OAAO,CAAEJ,CAAAA,eAAeI,GAAE,KAAM,AAACA,GAAkC,CAACJ,YAAY;AAClF;AAEO,SAASF,gBACdkB,QAAW,EACXC,SAAY;IAEZ,IAAI,CAAEjB,CAAAA,eAAegB,QAAO,GAAI;QAC9B,OAAO;YAAE,GAAGA,QAAQ;YAAE,GAAGC,SAAS;QAAC;IACrC;IAEA,MAAMZ,SAAS;QAAE,GAAGY,SAAS;IAAC;IAE9B,KAAK,MAAMJ,OAAO;QAACb;WAAgBO,OAAOO,IAAI,CAACE;KAAU,CAAE;QACzD,IAAIH,OAAOR,QAAQ;YAEjB;QACF;QAEAE,OAAOC,cAAc,CAACH,QAAQQ,KAAK;YACjCD,YAAYC,QAAQb;YACpBe,cAAcF,QAAQb;YACtBS;gBACE,OAAOO,QAAQ,CAACH,IAAe;YACjC;QACF;IACF;IAEA,OAAOR;AACT"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@pothos/plugin-drizzle",
+  "version": "0.0.1",
+  "description": "A Pothos plugin for drizzle",
+  "main": "./lib/index.js",
+  "types": "./dts/index.d.ts",
+  "module": "./esm/index.js",
+  "exports": {
+    "import": {
+      "default": "./esm/index.js"
+    },
+    "require": {
+      "types": "./dts/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hayes/pothos.git",
+    "directory": "packages/plugin-relay"
+  },
+  "author": "Michael Hayes",
+  "license": "ISC",
+  "keywords": [
+    "pothos",
+    "graphql",
+    "schema",
+    "typescript",
+    "drizzle",
+    "plugin"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "@pothos/core": "*",
+    "graphql": "^16.8.1"
+  },
+  "devDependencies": {
+    "@libsql/client": "^0.7.0",
+    "drizzle-graphql": "^0.8.4",
+    "drizzle-kit": "^0.23.0",
+    "drizzle-orm": "^0.32.0",
+    "graphql": "^16.8.1",
+    "graphql-scalars": "^1.23.0",
+    "graphql-tag": "^2.12.6",
+    "postgres": "^3.4.4",
+    "@pothos/core": "4.0.2",
+    "@pothos/plugin-add-graphql": "4.0.2",
+    "@pothos/plugin-relay": "4.0.2",
+    "@pothos/plugin-scope-auth": "4.0.2",
+    "@pothos/plugin-with-input": "4.0.2",
+    "@pothos/test-utils": "2.0.1"
+  },
+  "scripts": {
+    "type": "tsc --project tsconfig.type.json",
+    "build": "pnpm build:clean && pnpm build:cjs && pnpm build:dts && pnpm build:esm",
+    "build:clean": "git clean -dfX esm lib",
+    "build:cjs": "swc src -d lib --config-file ../../.swcrc -C module.type=commonjs",
+    "build:esm": "cp -r dts/* esm/ && swc src -d esm --config-file ../../.swcrc -C module.type=es6 && pnpm esm:extensions",
+    "build:dts": "tsc",
+    "esm:extensions": "TS_NODE_PROJECT=../../tsconfig.json node -r @swc-node/register ../../scripts/esm-transformer.ts",
+    "test": "pnpm vitest --run"
+  }
+}

package/src/drizzle-field-builder.ts

@@ -0,0 +1,500 @@
+import { getOperators, InferModelFromColumns, Many, TableRelationalConfig } from 'drizzle-orm';
+import {
+  CompatibleTypes,
+  ExposeNullability,
+  FieldKind,
+  FieldRef,
+  InputFieldMap,
+  InterfaceParam,
+  isThenable,
+  MaybePromise,
+  NormalizeArgs,
+  ObjectRef,
+  PluginName,
+  PothosSchemaError,
+  RootFieldBuilder,
+  SchemaTypes,
+  ShapeFromTypeParam,
+  TypeParam,
+} from '@pothos/core';
+import {
+  DrizzleConnectionShape,
+  ListRelation,
+  RelatedConnectionOptions,
+  RelatedFieldOptions,
+  ShapeFromConnection,
+  TypesForRelation,
+  VariantFieldOptions,
+} from './types';
+import { getRefFromModel } from './utils/refs';
+import {
+  drizzleCursorConnectionQuery,
+  getCursorFormatter,
+  wrapConnectionResult,
+} from './utils/cursors';
+import { SelectionMap } from './utils/selections';
+import { DrizzleRef } from './interface-ref';
+
+// Workaround for FieldKind not being extended on Builder classes
+const RootBuilder: {
+  // eslint-disable-next-line @typescript-eslint/prefer-function-type
+  new <Types extends SchemaTypes, Shape, Kind extends FieldKind>(
+    builder: PothosSchemaTypes.SchemaBuilder<Types>,
+    kind: FieldKind,
+    graphqlKind: PothosSchemaTypes.PothosKindToGraphQLType[FieldKind],
+  ): PothosSchemaTypes.RootFieldBuilder<Types, Shape, Kind>;
+} = RootFieldBuilder as never;
+
+const ops = getOperators();
+
+export class DrizzleObjectFieldBuilder<
+  Types extends SchemaTypes,
+  TableConfig extends TableRelationalConfig,
+  Shape,
+  ExposableShape = InferModelFromColumns<TableConfig['columns']>,
+> extends RootBuilder<Types, Shape, 'DrizzleObject'> {
+  exposeBoolean = this.createExpose('Boolean');
+
+  exposeFloat = this.createExpose('Float');
+
+  exposeInt = this.createExpose('Int');
+
+  exposeID = this.createExpose('ID');
+
+  exposeString = this.createExpose('String');
+
+  exposeBooleanList = this.createExpose(['Boolean']);
+
+  exposeFloatList = this.createExpose(['Float']);
+
+  exposeIntList = this.createExpose(['Int']);
+
+  exposeIDList = this.createExpose(['ID']);
+
+  exposeStringList = this.createExpose(['String']);
+
+  table: string;
+
+  typename: string;
+
+  relatedConnection: 'relay' extends PluginName
+    ? <
+        Field extends ListRelation<TableConfig>,
+        Nullable extends boolean,
+        Args extends InputFieldMap,
+        ConnectionInterfaces extends InterfaceParam<Types>[] = [],
+        EdgeInterfaces extends InterfaceParam<Types>[] = [],
+      >(
+        field: Field,
+        options: RelatedConnectionOptions<Types, Shape, TableConfig, Field, Nullable, Args>,
+        ...args: NormalizeArgs<
+          [
+            connectionOptions:
+              | ObjectRef<
+                  Types,
+                  ShapeFromConnection<
+                    PothosSchemaTypes.ConnectionShapeHelper<
+                      Types,
+                      TypesForRelation<Types, TableConfig['relations'][Field]>,
+                      false
+                    >
+                  >
+                >
+              | PothosSchemaTypes.ConnectionObjectOptions<
+                  Types,
+                  ObjectRef<
+                    Types,
+                    ShapeFromTypeParam<
+                      Types,
+                      [ObjectRef<Types, TypesForRelation<Types, TableConfig['relations'][Field]>>],
+                      Nullable
+                    >
+                  >,
+                  false,
+                  false,
+                  DrizzleConnectionShape<
+                    Types,
+                    ShapeFromTypeParam<
+                      Types,
+                      [ObjectRef<Types, TypesForRelation<Types, TableConfig['relations'][Field]>>],
+                      Nullable
+                    >,
+                    Shape,
+                    Args
+                  >,
+                  ConnectionInterfaces
+                >,
+            edgeOptions:
+              | ObjectRef<
+                  Types,
+                  {
+                    cursor: string;
+                    node?: TypesForRelation<Types, TableConfig['relations'][Field]>;
+                  }
+                >
+              | PothosSchemaTypes.ConnectionEdgeObjectOptions<
+                  Types,
+                  ObjectRef<
+                    Types,
+                    ShapeFromTypeParam<
+                      Types,
+                      [ObjectRef<Types, TypesForRelation<Types, TableConfig['relations'][Field]>>],
+                      Nullable
+                    >
+                  >,
+                  false,
+                  DrizzleConnectionShape<
+                    Types,
+                    ShapeFromTypeParam<
+                      Types,
+                      [ObjectRef<Types, TypesForRelation<Types, TableConfig['relations'][Field]>>],
+                      Nullable
+                    >,
+                    Shape,
+                    Args
+                  >,
+                  EdgeInterfaces
+                >,
+          ],
+          0
+        >
+      ) => FieldRef<
+        Types,
+        ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, Nullable>>
+      >
+    : '@pothos/plugin-relay is required to use this method' = function relatedConnection(
+    this: DrizzleObjectFieldBuilder<SchemaTypes, TableConfig, boolean>,
+    name: string,
+    {
+      maxSize = this.builder.options.drizzle?.maxConnectionSize,
+      defaultSize = this.builder.options.drizzle?.defaultConnectionSize,
+      query,
+      resolve,
+      extensions,
+      description,
+      ...options
+    }: {
+      type?: ObjectRef<Types, unknown, unknown>;
+      maxSize?: number | ((args: {}, ctx: {}) => number);
+      defaultSize?: number | ((args: {}, ctx: {}) => number);
+      extensions: {};
+      description?: string;
+      query: ((args: {}, ctx: {}) => {}) | {};
+      resolve: (
+        query: {},
+        parent: unknown,
+        args: {},
+        ctx: {},
+        info: {},
+      ) => MaybePromise<readonly {}[]>;
+    },
+    connectionOptions = {},
+    edgeOptions = {},
+  ) {
+    const relationField =
+      this.builder.options.drizzle.client._.schema?.[this.table].relations[name as string];
+    const relatedModel =
+      this.builder.options.drizzle.client._.schema?.[relationField?.referencedTableName!]!;
+
+    if (!relationField) {
+      throw new PothosSchemaError(
+        `Could not find relation ${name as string} on table ${this.table}`,
+      );
+    }
+
+    const ref = options.type ?? getRefFromModel(relationField.referencedTableName, this.builder);
+    let typeName: string | undefined;
+
+    const getQuery = (args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => {
+      const { limit, offset, orderBy, where, ...fieldQuery } =
+        (typeof query === 'function' ? query(args, ctx) : query) ?? {};
+
+      const { cursorColumns, columns, ...connectionQuery } = drizzleCursorConnectionQuery({
+        ctx,
+        maxSize,
+        defaultSize,
+        args,
+        orderBy: orderBy ? orderBy(relatedModel.columns) : relatedModel.primaryKey,
+        where: where ? where(relatedModel.columns, ops) : undefined,
+      });
+
+      return {
+        select: {
+          ...fieldQuery,
+          ...connectionQuery,
+          columns: {
+            ...fieldQuery.columns,
+            ...columns,
+          },
+          limit: Math.abs(limit ?? connectionQuery.limit),
+          offset: offset ?? connectionQuery.offset,
+        },
+        cursorColumns,
+      };
+    };
+
+    const relationSelect = (
+      args: object,
+      context: object,
+      nestedQuery: (query: unknown, path?: unknown) => { select?: {} },
+    ) => {
+      typeName ??= this.builder.configStore.getTypeConfig(ref).name;
+      const nested = nestedQuery(getQuery(args, context).select, {
+        getType: () => typeName!,
+        paths: [[{ name: 'nodes' }], [{ name: 'edges' }, { name: 'node' }]],
+      }) as SelectionMap;
+
+      return {
+        columns: {},
+        with: {
+          [name]: nested,
+        },
+      };
+    };
+    const fieldRef = (
+      this as unknown as {
+        connection: (...args: unknown[]) => FieldRef<Types, unknown>;
+      }
+    ).connection(
+      {
+        ...options,
+        extensions: {
+          ...extensions,
+          pothosDrizzleSelect: relationSelect,
+        },
+        type: ref,
+        resolve: (
+          parent: unknown,
+          args: PothosSchemaTypes.DefaultConnectionArguments,
+          context: {},
+        ) => {
+          const { select, cursorColumns } = getQuery(args, context);
+          return wrapConnectionResult(
+            (parent as Record<string, never>)[name],
+            args,
+            select.limit,
+            getCursorFormatter(cursorColumns),
+          );
+        },
+      },
+      connectionOptions instanceof ObjectRef
+        ? connectionOptions
+        : {
+            ...connectionOptions,
+          },
+      edgeOptions,
+    );
+    return fieldRef;
+  } as never;
+
+  constructor(
+    typename: string,
+    builder: PothosSchemaTypes.SchemaBuilder<Types>,
+    table: string,
+    graphqlKind: PothosSchemaTypes.PothosKindToGraphQLType[FieldKind] = 'Object',
+  ) {
+    super(builder, 'DrizzleObject', graphqlKind);
+
+    this.table = table;
+    this.typename = typename;
+  }
+
+  variant<
+    Variant extends DrizzleRef<Types, TableConfig['tsName']> | TableConfig['tsName'],
+    Args extends InputFieldMap,
+    Nullable,
+    ResolveShape,
+    ResolveReturn,
+  >(
+    variant: Variant,
+    ...allArgs: NormalizeArgs<
+      [
+        options: VariantFieldOptions<
+          Types,
+          TableConfig['tsName'] & keyof Types['DrizzleRelationSchema'],
+          Variant,
+          Args,
+          Nullable,
+          Shape,
+          ResolveShape,
+          ResolveReturn
+        >,
+      ]
+    >
+  ): FieldRef<Types, ResolveReturn, 'Object'> {
+    const [{ isNull, nullable, ...options } = {} as never] = allArgs;
+    const ref: DrizzleRef<Types> =
+      typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
+
+    const selfSelect = (args: object, context: object, nestedQuery: (query: unknown) => unknown) =>
+      nestedQuery({});
+
+    return this.field({
+      ...(options as {}),
+      type: ref,
+      extensions: {
+        ...options?.extensions,
+        pothosDrizzleSelect: selfSelect,
+      },
+      nullable: nullable ?? !!isNull,
+      resolve: isNull
+        ? (parent, args, context, info) => {
+            const parentIsNull = isNull(parent as never, args as never, context, info);
+            if (parentIsNull) {
+              if (isThenable(parentIsNull)) {
+                return parentIsNull.then((resolved) => (resolved ? null : parent)) as never;
+              }
+              return null as never;
+            }
+            return parent as never;
+          }
+        : (parent) => parent as never,
+    }) as FieldRef<Types, ResolveReturn, 'Object'>;
+  }
+
+  relation<
+    Field extends keyof TableConfig['relations'],
+    Nullable extends boolean,
+    Args extends InputFieldMap,
+    ResolveReturnShape,
+  >(
+    name: Field,
+    ...allArgs: NormalizeArgs<
+      [
+        options: RelatedFieldOptions<
+          Types,
+          TableConfig,
+          Field,
+          Nullable,
+          Args,
+          ResolveReturnShape,
+          Shape
+        >,
+      ]
+    >
+  ): FieldRef<Types, TypesForRelation<Types, TableConfig['relations'][Field]>, 'Object'> {
+    const [options = {} as never] = allArgs;
+    const relationField =
+      this.builder.options.drizzle.client._.schema?.[this.table].relations[name as string];
+
+    if (!relationField) {
+      throw new PothosSchemaError(
+        `Could not find relation ${name as string} on table ${this.table}`,
+      );
+    }
+
+    const ref = options.type ?? getRefFromModel(relationField.referencedTableName, this.builder);
+
+    const { query = {}, extensions, ...rest } = options;
+
+    const relationSelect = (args: object, context: object, nestedQuery: (query: unknown) => {}) => {
+      const relQuery = {
+        columns: {},
+        with: {
+          [name]: {
+            ...nestedQuery(query),
+            ...((typeof query === 'function'
+              ? (query as (args: {}, context: {}) => {})(args, context)
+              : query) as {}),
+          },
+        },
+      };
+
+      return relQuery;
+    };
+
+    return this.field({
+      ...(rest as {}),
+      type: relationField instanceof Many ? [ref] : ref,
+      extensions: {
+        ...extensions,
+        pothosDrizzleSelect: relationSelect as never,
+      },
+      resolve: (parent: Record<string, never>) => parent[name as string],
+    } as never) as never;
+  }
+
+  expose<
+    Type extends TypeParam<Types>,
+    Nullable extends boolean,
+    ResolveReturnShape,
+    Name extends CompatibleTypes<Types, ExposableShape, Type, Nullable>,
+  >(
+    ...args: NormalizeArgs<
+      [
+        name: Name,
+        options: ExposeNullability<Types, Type, ExposableShape, Name, Nullable> &
+          Omit<
+            PothosSchemaTypes.ObjectFieldOptions<
+              Types,
+              Shape,
+              Type,
+              Nullable,
+              {},
+              ResolveReturnShape
+            >,
+            'nullable' | 'resolve' | 'select'
+          >,
+      ]
+    >
+  ) {
+    const [name, options = {} as never] = args;
+
+    const typeConfig = this.builder.configStore.getTypeConfig(this.typename, 'Object');
+    const usingSelect = !!typeConfig.extensions?.pothosDrizzleSelect;
+
+    return this.exposeField(name as never, {
+      ...options,
+      extensions: {
+        ...options.extensions,
+        pothosDrizzleVariant: name,
+        pothosDrizzleSelect: usingSelect && {
+          columns: { [name as string]: true },
+        },
+      },
+    });
+  }
+
+  private createExpose<Type extends TypeParam<Types>>(type: Type) {
+    return <
+      Nullable extends boolean,
+      ResolveReturnShape,
+      Name extends CompatibleTypes<
+        Types,
+        ExposableShape,
+        Type,
+        Type extends [unknown] ? { list: true; items: true } : true
+      >,
+    >(
+      ...args: NormalizeArgs<
+        [
+          name: Name,
+          options: ExposeNullability<Types, Type, ExposableShape, Name, Nullable> &
+            Omit<
+              PothosSchemaTypes.ObjectFieldOptions<
+                Types,
+                ExposableShape,
+                Type,
+                Nullable,
+                {},
+                ResolveReturnShape
+              >,
+              'nullable' | 'resolve' | 'select' | 'type'
+            > & {
+              description?: string | false;
+            },
+        ]
+      >
+    ): FieldRef<Types, ShapeFromTypeParam<Types, Type, Nullable>, 'DrizzleObject'> => {
+      const [name, { description, ...options } = {} as never] = args;
+
+      return this.expose(
+        name as never,
+        {
+          ...options,
+          type,
+        } as never,
+      ) as never;
+    };
+  }
+}