pothos-drizzle-generator 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SoraKumo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# pothos-drizzle-generator
+
+A Pothos plugin that automatically generates GraphQL schemas based on Drizzle schema information.
+
+![](./documents/image.png)
+
+# usage
+
+To use this service, you must have version `drizzle-orm@1.0.0-beta.2` or later.
+
+```ts
+import "dotenv/config";
+import SchemaBuilder from "@pothos/core";
+import DrizzlePlugin from "@pothos/plugin-drizzle";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { getTableConfig } from "drizzle-orm/pg-core";
+import { relations } from "./db/relations";
+import PothosDrizzleGeneratorPlugin from "pothos-drizzle-generator";
+
+const db = drizzle({
+  connection: process.env.DATABASE_URL!,
+  relations,
+  logger: true,
+});
+
+export interface PothosTypes {
+  DrizzleRelations: typeof relations;
+  Context: { userId?: string };
+}
+
+const builder = new SchemaBuilder<PothosTypes>({
+  plugins: [
+    DrizzlePlugin,
+    PothosDrizzleGeneratorPlugin, // Set plugin
+  ],
+  drizzle: {
+    client: () => db,
+    relations,
+    getTableConfig,
+  },
+});
+
+const schema = builder.toSchema();
+```
+
+# Options
+
+```ts
+const builder = new SchemaBuilder<PothosTypes>({
+  plugins: [
+    DrizzlePlugin,
+    PothosDrizzleGeneratorPlugin, // Set plugin
+  ],
+  drizzle: {
+    client: () => db,
+    relations,
+    getTableConfig,
+  },
+  pothosDrizzleGenerator: {
+    // Specifying the Maximum Query Depth
+    depthLimit: ({ ctx, modelName, operation }) => $limit$,
+    // Specifying the model to use
+    use: { include: [...$modelNames$], exclude: [...$modelNames$] },
+    models: {
+      [$modelName$]: {
+        // Specifying fields to use in queries
+        fields: { include: [...$fields$], exclude: [...$fields$] },
+        // Specifying the method of operation for the model
+        operations: { include: [...$operation$], exclude: [...$operation$] },
+        // Runtime Permission Check
+        executable: ({ ctx, modelName, operation }) => $permission$,
+        // Specify the maximum value for the query's limit
+        limit: ({ ctx, modelName, operation }) => $limit$,
+        // Override the query's orderBy
+        orderBy: ({ ctx, modelName, operation }) => $orderBy$,
+        // Add query conditions
+        where: ({ ctx, modelName, operation }) => $where$,
+        // Specifying input fields
+        inputFields: { include: [$fields$], exclude: [$fields$] },
+        // Overwriting input data
+        inputData: ({ ctx, modelName, operation }) => $inputData$,
+      },
+    },
+  },
+});
+```
+
+# Current implementation status
+
+## Operations
+
+- findMany
+- findFirst
+- count
+- create
+- update
+- delete
+
+## Parameters
+
+- where
+- orderBy
+- offset
+- limit
+
+## operators
+
+- AND
+- OR
+- NOT
+- eq
+- ne
+- gt
+- gte
+- lt
+- lte
+- like
+- notLike
+- ilike
+- notIlike
+- isNull
+- isNotNull,
+- in,
+- notIn
+- arrayContained
+- arrayOverlaps
+- arrayContains

package/dist/cjs/PothosDrizzleGeneratorPlugin.d.ts

@@ -0,0 +1,7 @@
+import { BasePlugin, type BuildCache, type SchemaTypes } from "@pothos/core";
+import { PothosDrizzleGenerator } from "./generator.js";
+export declare class PothosDrizzleGeneratorPlugin<Types extends SchemaTypes, T extends object = object> extends BasePlugin<Types, T> {
+    generator: PothosDrizzleGenerator;
+    constructor(buildCache: BuildCache<Types>, name: keyof PothosSchemaTypes.Plugins<Types>);
+    beforeBuild(): void;
+}

package/dist/cjs/PothosDrizzleGeneratorPlugin.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PothosDrizzleGeneratorPlugin = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const core_1 = require("@pothos/core");
+const drizzle_orm_1 = require("drizzle-orm");
+const generator_js_1 = require("./generator.js");
+const utils_js_1 = require("./libs/utils.js");
+class PothosDrizzleGeneratorPlugin extends core_1.BasePlugin {
+    generator;
+    constructor(buildCache, name) {
+        super(buildCache, name);
+        this.generator = new generator_js_1.PothosDrizzleGenerator(this.builder);
+    }
+    beforeBuild() {
+        const generator = this.generator;
+        const builder = this.builder;
+        const depthLimit = generator.getDepthLimit();
+        const tables = generator.getTables();
+        for (const [modelName, { table, tableInfo, relations, columns, operations, executable, limit, where, orderBy, inputData, },] of Object.entries(tables)) {
+            const objectRef = builder.objectRef(modelName);
+            objectRef.implement({
+                fields: (t) => Object.fromEntries(columns.map((c) => {
+                    return [
+                        c.name,
+                        t.expose(c.name, {
+                            type: generator.getDataType(c),
+                            nullable: !c.notNull,
+                        }),
+                    ];
+                })),
+            });
+            const filterRelations = Object.entries(relations).filter(([, relay]) => tables[relay.targetTableName]);
+            builder.drizzleObject(modelName, {
+                name: tableInfo.name,
+                fields: (t) => {
+                    const relayList = filterRelations.map(([relayName, relay]) => {
+                        const modelName = relay.targetTableName;
+                        const { executable, where, orderBy, limit, operations } = tables[modelName];
+                        const operation = relay.relationType === "one" ? "findFirst" : "findMany";
+                        if (!operations.includes(operation))
+                            return [];
+                        const inputWhere = generator.getInputWhere(modelName);
+                        const inputOrderBy = generator.getInputOrderBy(modelName);
+                        return [
+                            relayName,
+                            t.relation(relayName, {
+                                columns: { id: true },
+                                args: {
+                                    offset: t.arg({ type: "Int" }),
+                                    limit: t.arg({ type: "Int" }),
+                                    where: t.arg({ type: inputWhere }),
+                                    orderBy: t.arg({ type: inputOrderBy }),
+                                },
+                                query: (args, ctx) => {
+                                    if (executable?.({
+                                        modelName,
+                                        ctx,
+                                        operation,
+                                    }) === false) {
+                                        throw new Error("No permission");
+                                    }
+                                    const p = {
+                                        limit: limit?.({ modelName, ctx, operation }),
+                                        where: where?.({ modelName, ctx, operation }),
+                                        orderBy: orderBy?.({ modelName, ctx, operation }),
+                                    };
+                                    return {
+                                        ...args,
+                                        limit: p.limit && args.limit
+                                            ? Math.min(p.limit, args.limit)
+                                            : p.limit ?? args.limit,
+                                        where: { AND: [args.where, p.where].filter((v) => v) },
+                                        orderBy: args.orderBy && Object.keys(args.orderBy).length
+                                            ? args.orderBy
+                                            : p.orderBy,
+                                    };
+                                },
+                            }),
+                        ];
+                    });
+                    const relayCount = filterRelations.map(([relayName, relay]) => {
+                        const modelName = relay.targetTableName;
+                        const operation = "count";
+                        const { executable, where, operations } = tables[modelName];
+                        if (!operations.includes(operation))
+                            return [];
+                        const inputWhere = generator.getInputWhere(modelName);
+                        return [
+                            `${relayName}Count`,
+                            t.relatedCount(relayName, {
+                                args: { where: t.arg({ type: inputWhere }) },
+                                where: (args, ctx) => {
+                                    if (executable?.({
+                                        modelName,
+                                        ctx,
+                                        operation,
+                                    }) === false) {
+                                        throw new Error("No permission");
+                                    }
+                                    const p = {
+                                        where: where?.({ modelName, ctx, operation }),
+                                    };
+                                    return (0, utils_js_1.createWhereQuery)(relay.targetTable, {
+                                        AND: [args.where, p.where].filter((v) => v),
+                                    });
+                                },
+                            }),
+                        ];
+                    });
+                    return Object.fromEntries([
+                        ...relayCount,
+                        ...relayList,
+                        ...columns.map((c) => {
+                            return [
+                                c.name,
+                                t.expose(c.name, {
+                                    type: generator.getDataType(c),
+                                    nullable: !c.notNull,
+                                }),
+                            ];
+                        }),
+                    ]);
+                },
+            });
+            const inputWhere = generator.getInputWhere(modelName);
+            const inputOrderBy = generator.getInputOrderBy(modelName);
+            const inputCreate = generator.getInputCreate(modelName);
+            const inputUpdate = generator.getInputUpdate(modelName);
+            if (operations.includes("findMany")) {
+                builder.queryType({
+                    fields: (t) => ({
+                        [`findMany${tableInfo.name}`]: t.drizzleField({
+                            type: [modelName],
+                            nullable: false,
+                            args: {
+                                offset: t.arg({ type: "Int" }),
+                                limit: t.arg({ type: "Int" }),
+                                where: t.arg({ type: inputWhere }),
+                                orderBy: t.arg({ type: inputOrderBy }),
+                            },
+                            resolve: async (query, _parent, args, ctx, info) => {
+                                const operation = "findMany";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    limit: limit?.({ modelName, ctx, operation }),
+                                    where: where?.({ modelName, ctx, operation }),
+                                    orderBy: orderBy?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx).query[modelName].findMany(query({
+                                    ...args,
+                                    limit: p.limit && args.limit
+                                        ? Math.min(p.limit, args.limit)
+                                        : p.limit ?? args.limit,
+                                    where: { AND: [args.where, p.where].filter((v) => v) },
+                                    orderBy: args.orderBy && Object.keys(args.orderBy).length
+                                        ? args.orderBy
+                                        : p.orderBy,
+                                }));
+                            },
+                        }),
+                    }),
+                });
+            }
+            if (operations.includes("findFirst")) {
+                builder.queryType({
+                    fields: (t) => ({
+                        [`findFirst${tableInfo.name}`]: t.drizzleField({
+                            type: modelName,
+                            args: {
+                                offset: t.arg({ type: "Int" }),
+                                where: t.arg({ type: inputWhere }),
+                                orderBy: t.arg({ type: inputOrderBy }),
+                            },
+                            resolve: async (query, _parent, args, ctx, info) => {
+                                const operation = "findFirst";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    where: where?.({ modelName, ctx, operation }),
+                                    orderBy: orderBy?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx).query[modelName].findFirst(query({
+                                    ...args,
+                                    where: { AND: [args.where, p.where].filter((v) => v) },
+                                    orderBy: args.orderBy && Object.keys(args.orderBy).length
+                                        ? args.orderBy
+                                        : p.orderBy,
+                                }));
+                            },
+                        }),
+                    }),
+                });
+            }
+            if (operations.includes("count")) {
+                builder.queryType({
+                    fields: (t) => ({
+                        [`count${tableInfo.name}`]: t.field({
+                            type: "Int",
+                            nullable: false,
+                            args: {
+                                limit: t.arg({ type: "Int" }),
+                                where: t.arg({ type: inputWhere }),
+                            },
+                            resolve: async (_query, _parent, args, ctx, info) => {
+                                const operation = "count";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    limit: limit?.({ modelName, ctx, operation }),
+                                    where: where?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx).query[modelName]
+                                    .findFirst({
+                                    columns: {},
+                                    extras: { _count: () => (0, drizzle_orm_1.sql) `count(*)` },
+                                    ...args,
+                                    limit: p.limit && args.limit
+                                        ? Math.min(p.limit, args.limit)
+                                        : p.limit ?? args.limit,
+                                    where: { AND: [args.where, p.where].filter((v) => v) },
+                                })
+                                    .then((v) => v._count);
+                            },
+                        }),
+                    }),
+                });
+            }
+            if (operations.includes("createOne")) {
+                builder.mutationType({
+                    fields: (t) => ({
+                        [`createOne${tableInfo.name}`]: t.drizzleField({
+                            type: modelName,
+                            nullable: false,
+                            args: { input: t.arg({ type: inputCreate, required: true }) },
+                            resolve: async (_query, _parent, args, ctx, info) => {
+                                const operation = "createOne";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    input: inputData?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx)
+                                    .insert(table)
+                                    .values({ ...args.input, ...p.input })
+                                    .returning()
+                                    .then((v) => v[0]);
+                            },
+                        }),
+                    }),
+                });
+            }
+            if (operations.includes("createMany")) {
+                builder.mutationType({
+                    fields: (t) => ({
+                        [`createMany${tableInfo.name}`]: t.drizzleField({
+                            type: [modelName],
+                            nullable: false,
+                            args: { input: t.arg({ type: [inputCreate], required: true }) },
+                            resolve: async (_query, _parent, args, ctx, info) => {
+                                const operation = "createMany";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    args: inputData?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx)
+                                    .insert(table)
+                                    .values(args.input.map((v) => ({ ...v, ...p.args })))
+                                    .returning();
+                            },
+                        }),
+                    }),
+                });
+            }
+            if (operations.includes("update")) {
+                builder.mutationType({
+                    fields: (t) => ({
+                        [`update${tableInfo.name}`]: t.drizzleField({
+                            type: [modelName],
+                            nullable: false,
+                            args: {
+                                input: t.arg({ type: inputUpdate, required: true }),
+                                where: t.arg({ type: inputWhere }),
+                            },
+                            resolve: async (_query, _parent, args, ctx, info) => {
+                                const operation = "update";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    where: where?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx)
+                                    .update(table)
+                                    .set(args.input)
+                                    .where((0, utils_js_1.createWhereQuery)(table, {
+                                    AND: [args.where, p.where].filter((v) => v),
+                                }))
+                                    .returning();
+                            },
+                        }),
+                    }),
+                });
+            }
+            if (operations.includes("delete")) {
+                builder.mutationType({
+                    fields: (t) => ({
+                        [`delete${tableInfo.name}`]: t.field({
+                            type: [modelName],
+                            nullable: false,
+                            args: {
+                                where: t.arg({ type: inputWhere }),
+                            },
+                            resolve: async (_parent, args, ctx, info) => {
+                                const operation = "delete";
+                                if (executable?.({
+                                    modelName,
+                                    ctx,
+                                    operation,
+                                }) === false) {
+                                    throw new Error("No permission");
+                                }
+                                const p = {
+                                    depthLimit: depthLimit?.({ modelName, ctx, operation }),
+                                    where: where?.({ modelName, ctx, operation }),
+                                };
+                                if (p.depthLimit !== undefined &&
+                                    (0, utils_js_1.getQueryDepth)(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx)
+                                    .delete(table)
+                                    .where((0, utils_js_1.createWhereQuery)(table, {
+                                    AND: [args.where, p.where].filter((v) => v),
+                                }))
+                                    .returning();
+                            },
+                        }),
+                    }),
+                });
+            }
+        }
+    }
+}
+exports.PothosDrizzleGeneratorPlugin = PothosDrizzleGeneratorPlugin;

package/dist/cjs/generator.d.ts

@@ -0,0 +1,63 @@
+import { type AnyRelations, type RelationsRecord, type SchemaEntry } from "drizzle-orm";
+import { OperationBasic } from "./libs/operations.js";
+import type { DrizzleClient } from "@pothos/plugin-drizzle";
+import type { PgColumn, getTableConfig } from "drizzle-orm/pg-core";
+type ModelData = {
+    table: SchemaEntry;
+    operations: (typeof OperationBasic)[number][];
+    columns: PgColumn<any, object>[];
+    inputColumns: PgColumn<any, object>[];
+    tableInfo: ReturnType<typeof getTableConfig>;
+    relations: RelationsRecord;
+    executable?: (params: {
+        ctx: any;
+        modelName: string;
+        operation: (typeof OperationBasic)[number];
+    }) => boolean | undefined;
+    limit?: (params: {
+        ctx: any;
+        modelName: string;
+        operation: (typeof OperationBasic)[number];
+    }) => number | undefined;
+    orderBy?: (params: {
+        ctx: any;
+        modelName: string;
+        operation: (typeof OperationBasic)[number];
+    }) => object | undefined;
+    where?: (params: {
+        ctx: any;
+        modelName: string;
+        operation: (typeof OperationBasic)[number];
+    }) => object | undefined;
+    inputData?: (params: {
+        ctx: any;
+        modelName: string;
+        operation: (typeof OperationBasic)[number];
+    }) => object | undefined;
+};
+export declare class PothosDrizzleGenerator {
+    enums: Record<string, PothosSchemaTypes.EnumRef<any, any>>;
+    inputOperators: Record<string, PothosSchemaTypes.InputObjectRef<any, any>>;
+    inputType: Record<string, Record<string, PothosSchemaTypes.InputObjectRef<any, any>>>;
+    tables?: Record<string, ModelData>;
+    builder: PothosSchemaTypes.SchemaBuilder<any>;
+    constructor(builder: PothosSchemaTypes.SchemaBuilder<any>);
+    createTableInfo(): Record<string, ModelData>;
+    getClient(ctx: any): DrizzleClient;
+    getRelations(): AnyRelations;
+    getTables(): Record<string, ModelData>;
+    getDepthLimit(): ((params: {
+        ctx: any;
+        modelName: string | number | symbol;
+        operation: (typeof OperationBasic)[number];
+    }) => number | undefined) | undefined;
+    getInputType(modelName: string, type: string, options: PothosSchemaTypes.InputObjectTypeOptions<any, any>): PothosSchemaTypes.InputObjectRef<any, any>;
+    getInputCreate(modelName: string): PothosSchemaTypes.InputObjectRef<any, any>;
+    getInputUpdate(modelName: string): PothosSchemaTypes.InputObjectRef<any, any>;
+    getInputWhere(modelName: string): PothosSchemaTypes.InputObjectRef<any, any>;
+    getInputOrderBy(modelName: string): PothosSchemaTypes.InputObjectRef<any, any>;
+    getInputOperator(type: string | [string]): PothosSchemaTypes.InputObjectRef<any, any>;
+    createInputType(): void;
+    getDataType(column: PgColumn): string | [string];
+}
+export {};