pothos-drizzle-generator 0.0.1

package/dist/cjs/generator.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PothosDrizzleGenerator = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const drizzle_orm_1 = require("drizzle-orm");
+const graphql_scalars_1 = require("graphql-scalars");
+const operations_js_1 = require("./libs/operations.js");
+const utils_js_1 = require("./libs/utils.js");
+class PothosDrizzleGenerator {
+    enums = {};
+    inputOperators = {};
+    inputType = {};
+    tables;
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+        this.createInputType();
+    }
+    createTableInfo() {
+        const options = this.builder.options.pothosDrizzleGenerator;
+        const drizzleOption = this.builder.options.drizzle;
+        const getConfig = drizzleOption.getTableConfig;
+        const relations = this.getRelations();
+        const tables = Object.values(relations)
+            .filter((t) => (0, drizzle_orm_1.isTable)(t.table))
+            .map(({ name, table, relations }) => {
+            const tableInfo = getConfig(table);
+            const modelOptions = options?.models?.[name];
+            const columns = tableInfo.columns;
+            //Operations
+            const operationIncludes = (0, operations_js_1.expandOperations)(modelOptions?.operations?.include ?? operations_js_1.OperationBasic);
+            const operationExcludes = (0, operations_js_1.expandOperations)(modelOptions?.operations?.exclude ?? []);
+            const operations = operationIncludes.filter((v) => !operationExcludes.includes(v));
+            // Columns filter
+            const include = options?.models?.[name]?.fields?.include ??
+                columns.map((c) => c.name);
+            const exclude = options?.models?.[name]?.fields?.exclude ?? [];
+            const filterColumns = include.filter((name) => !exclude.includes(name));
+            // Input columns filter
+            const includeInput = options?.models?.[name]?.inputFields?.include ??
+                columns.map((c) => c.name);
+            const excludeInput = options?.models?.[name]?.inputFields?.exclude ?? [];
+            const filterInputColumns = includeInput.filter((name) => !excludeInput.includes(name));
+            return [
+                name,
+                {
+                    table,
+                    columns: columns.filter((c) => filterColumns.includes(c.name)),
+                    operations,
+                    inputColumns: columns.filter((c) => filterInputColumns.includes(c.name)),
+                    tableInfo,
+                    relations,
+                    executable: modelOptions?.executable,
+                    limit: modelOptions?.limit,
+                    orderBy: modelOptions?.orderBy,
+                    where: modelOptions?.where,
+                    inputData: modelOptions?.inputData,
+                },
+            ];
+        });
+        const modelNames = tables.map(([name]) => name);
+        // Model filter
+        const include = options?.use?.include ?? modelNames;
+        const exclude = options?.use?.exclude ?? [];
+        const filterTables = include.filter((name) => !exclude.includes(name));
+        return Object.fromEntries(tables.filter(([name]) => filterTables.includes(name)));
+    }
+    getClient(ctx) {
+        const options = this.builder.options;
+        const drizzleOption = options.drizzle;
+        const client = drizzleOption.client instanceof Function
+            ? drizzleOption.client(ctx)
+            : drizzleOption.client;
+        return client;
+    }
+    getRelations() {
+        const drizzleOption = this.builder.options.drizzle;
+        const client = drizzleOption.client;
+        return drizzleOption.relations ?? client._.relations;
+    }
+    getTables() {
+        if (this.tables)
+            return this.tables;
+        const tables = this.createTableInfo();
+        this.tables = tables;
+        return tables;
+    }
+    getDepthLimit() {
+        const options = this.builder.options.pothosDrizzleGenerator;
+        return options?.depthLimit;
+    }
+    getInputType(modelName, type, options) {
+        if (!this.inputType[modelName])
+            this.inputType[modelName] = {};
+        if (this.inputType[modelName][type])
+            return this.inputType[modelName][type];
+        const { tableInfo } = this.getTables()[modelName];
+        const input = this.builder.inputType(`${tableInfo.name}${type}`, options);
+        this.inputType[modelName][type] = input;
+        return input;
+    }
+    getInputCreate(modelName) {
+        const { inputColumns } = this.getTables()[modelName];
+        return this.getInputType(modelName, "Create", {
+            fields: (t) => Object.fromEntries(inputColumns.map((c) => [
+                c.name,
+                t.field({
+                    type: this.getDataType(c),
+                    required: c.notNull && !c.default,
+                }),
+            ])),
+        });
+    }
+    getInputUpdate(modelName) {
+        const { inputColumns } = this.getTables()[modelName];
+        return this.getInputType(modelName, "Input", {
+            fields: (t) => {
+                return Object.fromEntries(inputColumns.map((c) => [
+                    c.name,
+                    t.field({
+                        type: this.getDataType(c),
+                    }),
+                ]));
+            },
+        });
+    }
+    getInputWhere(modelName) {
+        const { tableInfo } = this.getTables()[modelName];
+        const inputWhere = this.getInputType(modelName, "Where", {
+            fields: (t) => {
+                return Object.fromEntries([
+                    ["AND", t.field({ type: [inputWhere] })],
+                    ["OR", t.field({ type: [inputWhere] })],
+                    ["NOT", t.field({ type: inputWhere })],
+                    ...tableInfo.columns.map((c) => {
+                        return [
+                            c.name,
+                            t.field({
+                                type: this.getInputOperator(this.getDataType(c)),
+                            }),
+                        ];
+                    }),
+                ]);
+            },
+        });
+        return inputWhere;
+    }
+    getInputOrderBy(modelName) {
+        const { tableInfo } = this.getTables()[modelName];
+        const inputWhere = this.getInputType(modelName, "OrderBy", {
+            fields: (t) => {
+                return Object.fromEntries(tableInfo.columns.map((c) => {
+                    return [
+                        c.name,
+                        t.field({
+                            type: this.enums["OrderBy"],
+                        }),
+                    ];
+                }));
+            },
+        });
+        return inputWhere;
+    }
+    getInputOperator(type) {
+        const typeName = Array.isArray(type) ? `Array${type[0]}` : type;
+        const input = this.inputOperators[typeName] ?? (0, utils_js_1.createInputOperator)(this.builder, type);
+        this.inputOperators[typeName] = input;
+        return input;
+    }
+    createInputType() {
+        const builder = this.builder;
+        const scalars = [
+            ["BigInt", graphql_scalars_1.BigIntResolver],
+            ["Date", graphql_scalars_1.DateResolver],
+            ["Bytes", graphql_scalars_1.ByteResolver],
+            ["DateTime", graphql_scalars_1.DateTimeResolver],
+            ["Json", graphql_scalars_1.JSONResolver],
+            ["Decimal", graphql_scalars_1.HexadecimalResolver],
+        ];
+        for (const [scalarName, scalarResolver] of scalars) {
+            if (!builder.configStore.hasConfig(scalarName)) {
+                builder.addScalarType(scalarName, scalarResolver, {});
+            }
+        }
+        this.enums["OrderBy"] = builder.enumType("OrderBy", {
+            values: {
+                Asc: { value: "asc" },
+                Desc: { value: "desc" },
+            },
+        });
+    }
+    getDataType(column) {
+        const isArray = column.dataType.split(" ")[0] === "array";
+        const c = isArray ? column.baseColumn : column;
+        const types = c.dataType.split(" ");
+        switch (types[1] ?? types[0]) {
+            case "enum": {
+                const sqlType = c.getSQLType();
+                const e = this.enums[sqlType];
+                if (!e) {
+                    this.enums[sqlType] = this.builder.enumType(sqlType, {
+                        values: c.enumValues ?? [],
+                    });
+                }
+                return isArray ? [sqlType] : sqlType;
+            }
+            case "json":
+                return isArray ? ["Json"] : "Json";
+            case "date":
+                return isArray ? ["DateTime"] : "DateTime";
+            case "datetime":
+                return isArray ? ["DateTime"] : "DateTime";
+            case "boolean":
+                return isArray ? ["Boolean"] : "Boolean";
+            case "double":
+            case "float":
+            case "udouble":
+            case "ufloat":
+                return isArray ? ["Float"] : "Float";
+        }
+        const type = isArray ? types[1] : types[0];
+        const scalerMap = {
+            bigint: "BigInt",
+            number: "Float",
+            string: "String",
+        };
+        const result = scalerMap[type] ?? "String";
+        return isArray ? [result] : result;
+    }
+}
+exports.PothosDrizzleGenerator = PothosDrizzleGenerator;

package/dist/cjs/global-types.d.ts

@@ -0,0 +1,80 @@
+import { SchemaTypes } from "@pothos/core";
+import type { PothosDrizzleGeneratorPlugin } from "./PothosDrizzleGeneratorPlugin";
+import type { DBQueryConfigColumns, GetTableViewFieldSelection, RelationsFilter } from "drizzle-orm";
+import type { Operation, OperationBasic } from "./libs/operations.js";
+import type { PgInsertValue, PgTable } from "drizzle-orm/pg-core";
+declare global {
+    export namespace PothosSchemaTypes {
+        interface Plugins<Types extends SchemaTypes, T extends object = object> {
+            pothosDrizzleGenerator: PothosDrizzleGeneratorPlugin<Types, T>;
+        }
+        type Relations<Types extends SchemaTypes> = Types["DrizzleRelations"];
+        type Tables<Types extends SchemaTypes> = keyof Relations<Types>;
+        type Columns<Types extends SchemaTypes, U extends Tables<Types>> = keyof DBQueryConfigColumns<GetTableViewFieldSelection<Relations<Types>[U]["table"]>>;
+        interface SchemaBuilderOptions<Types extends SchemaTypes> {
+            pothosDrizzleGenerator?: {
+                depthLimit?: (params: {
+                    ctx: Types["Context"];
+                    modelName: Tables<Types>;
+                    operation: (typeof OperationBasic)[number];
+                }) => number | undefined;
+                use?: {
+                    include: (keyof Relations<Types>)[];
+                    exclude?: undefined;
+                } | {
+                    exclude: (keyof Relations<Types>)[];
+                    include?: undefined;
+                };
+                models?: {
+                    [U in Tables<Types>]?: {
+                        fields?: {
+                            include: Columns<Types, U>[];
+                            exclude?: undefined;
+                        } | {
+                            exclude: Columns<Types, U>[];
+                            include?: undefined;
+                        };
+                        operations?: {
+                            include?: Operation[];
+                            exclude?: Operation[];
+                        };
+                        executable?: (params: {
+                            ctx: Types["Context"];
+                            modelName: U;
+                            operation: (typeof OperationBasic)[number];
+                        }) => boolean;
+                        limit?: (params: {
+                            ctx: Types["Context"];
+                            modelName: U;
+                            operation: (typeof OperationBasic)[number];
+                        }) => number | undefined;
+                        orderBy?: (params: {
+                            ctx: Types["Context"];
+                            modelName: U;
+                            operation: (typeof OperationBasic)[number];
+                        }) => {
+                            [P in Columns<Types, U>]?: "asc" | "desc";
+                        } | undefined;
+                        where?: (params: {
+                            ctx: Types["Context"];
+                            modelName: U;
+                            operation: (typeof OperationBasic)[number];
+                        }) => RelationsFilter<Relations<Types>[U], Relations<Types>> | undefined;
+                        inputFields?: {
+                            include: Columns<Types, U>[];
+                            exclude?: undefined;
+                        } | {
+                            exclude: Columns<Types, U>[];
+                            include?: undefined;
+                        };
+                        inputData?: (params: {
+                            ctx: Types["Context"];
+                            modelName: U;
+                            operation: (typeof OperationBasic)[number];
+                        }) => PgInsertValue<Relations<Types>[U]["table"] extends PgTable ? Relations<Types>[U]["table"] : never, true> | undefined;
+                    };
+                };
+            };
+        }
+    }
+}

package/dist/cjs/global-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./global-types.js";
+declare const pluginName: "pothosDrizzleGenerator";
+export default pluginName;

package/dist/cjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = __importDefault(require("@pothos/core"));
+const PothosDrizzleGeneratorPlugin_js_1 = require("./PothosDrizzleGeneratorPlugin.js");
+__exportStar(require("./global-types.js"), exports);
+const pluginName = "pothosDrizzleGenerator";
+const allowPluginReRegistration = core_1.default.allowPluginReRegistration;
+core_1.default.allowPluginReRegistration = true;
+core_1.default.registerPlugin(pluginName, PothosDrizzleGeneratorPlugin_js_1.PothosDrizzleGeneratorPlugin);
+core_1.default.allowPluginReRegistration = allowPluginReRegistration;
+exports.default = pluginName;

package/dist/cjs/libs/operations.d.ts

@@ -0,0 +1,11 @@
+export declare const OperationFind: readonly ["findFirst", "findMany"];
+export declare const OperationQuery: readonly ["findFirst", "findMany", "count"];
+export declare const OperationCreate: readonly ["createOne", "createMany"];
+export declare const OperationUpdate: readonly ["update"];
+export declare const OperationDelete: readonly ["delete"];
+export declare const OperationMutation: readonly ["createOne", "createMany", "update", "delete"];
+export declare const OperationBasic: readonly ["findFirst", "findMany", "count", "createOne", "createMany", "update", "delete"];
+export declare const OperationAll: readonly ["find", "update", "delete", "query", "mutation", "findFirst", "findMany", "count", "createOne", "createMany", "update", "delete"];
+export type Operation = (typeof OperationAll)[number] | "all";
+export declare const expandOperations: (operations: readonly Operation[]) => ("findFirst" | "findMany" | "count" | "createOne" | "createMany" | "update" | "delete")[];
+export declare const isOperation: (operations: readonly string[], operation: (typeof OperationBasic)[number]) => boolean;

package/dist/cjs/libs/operations.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOperation = exports.expandOperations = exports.OperationAll = exports.OperationBasic = exports.OperationMutation = exports.OperationDelete = exports.OperationUpdate = exports.OperationCreate = exports.OperationQuery = exports.OperationFind = void 0;
+exports.OperationFind = ["findFirst", "findMany"];
+exports.OperationQuery = [...exports.OperationFind, "count"];
+exports.OperationCreate = ["createOne", "createMany"];
+exports.OperationUpdate = ["update"];
+exports.OperationDelete = ["delete"];
+exports.OperationMutation = [
+    ...exports.OperationCreate,
+    ...exports.OperationUpdate,
+    ...exports.OperationDelete,
+];
+exports.OperationBasic = [
+    ...exports.OperationQuery,
+    ...exports.OperationMutation,
+];
+exports.OperationAll = [
+    "find",
+    "update",
+    "delete",
+    "query",
+    "mutation",
+    ...exports.OperationBasic,
+];
+const expandOperations = (operations) => {
+    return operations.flatMap((v) => v === "all"
+        ? exports.OperationBasic
+        : v === "find"
+            ? exports.OperationFind
+            : v === "update"
+                ? exports.OperationUpdate
+                : v === "delete"
+                    ? exports.OperationDelete
+                    : v === "query"
+                        ? exports.OperationQuery
+                        : v === "mutation"
+                            ? exports.OperationMutation
+                            : [v]);
+};
+exports.expandOperations = expandOperations;
+const isOperation = (operations, operation) => {
+    return operations.includes(operation);
+};
+exports.isOperation = isOperation;

package/dist/cjs/libs/utils.d.ts

@@ -0,0 +1,58 @@
+import * as p from "drizzle-orm";
+import { GraphQLResolveInfo } from "graphql";
+export declare function getQueryDepth(info: GraphQLResolveInfo): number;
+export declare const getQueryFields: (info: GraphQLResolveInfo) => {
+    [k: string]: boolean;
+};
+declare const OperatorMap: {
+    eq: p.BinaryOperator;
+    ne: p.BinaryOperator;
+    gt: p.BinaryOperator;
+    gte: p.BinaryOperator;
+    lt: p.BinaryOperator;
+    lte: p.BinaryOperator;
+    like: typeof p.like;
+    notLike: typeof p.notLike;
+    ilike: typeof p.ilike;
+    notIlike: typeof p.notIlike;
+    isNull: typeof p.isNull;
+    isNotNull: typeof p.isNotNull;
+    in: typeof p.inArray;
+    notIn: typeof p.notInArray;
+    arrayContained: typeof p.arrayContained;
+    arrayOverlaps: typeof p.arrayOverlaps;
+    arrayContains: typeof p.arrayContains;
+};
+type OperatorType = Record<string, Record<keyof typeof OperatorMap, unknown>>;
+type OperatorTree = Record<"AND" | "OR", OperatorType[]> | Record<"NOT", OperatorType> | OperatorType;
+export declare const createWhereQuery: (table: p.SchemaEntry, tree?: OperatorTree) => p.SQL | undefined;
+export declare const createInputOperator: (builder: PothosSchemaTypes.SchemaBuilder<any>, type: string | [string]) => PothosSchemaTypes.InputObjectRef<any, {
+    eq?: any;
+    ne?: any;
+    gt?: any;
+    gte?: any;
+    lt?: any;
+    lte?: any;
+    like?: any;
+    notLike?: any;
+    ilike?: any;
+    notIlike?: any;
+    isNull?: any;
+    isNotNull?: any;
+    in: never;
+    notIn: never;
+    arrayContained: never;
+    arrayOverlaps: never;
+    arrayContains: never;
+}>;
+type AggregationQueryType = {
+    aggregation?: boolean;
+    columns?: object;
+    with: Record<string, AggregationQueryType>;
+};
+export declare const convertAggregationQuery: (query: AggregationQueryType) => {
+    with: Record<string, AggregationQueryType>;
+    aggregation?: boolean;
+    columns?: object;
+};
+export {};

package/dist/cjs/libs/utils.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAggregationQuery = exports.createInputOperator = exports.createWhereQuery = exports.getQueryFields = void 0;
+exports.getQueryDepth = getQueryDepth;
+const utils_1 = require("@graphql-tools/utils");
+const p = __importStar(require("drizzle-orm"));
+function getDepthFromSelection(selection, currentDepth) {
+    if (selection.kind === "Field" && selection.selectionSet) {
+        // 子フィールドがある場合はさらに深さを加算
+        const childDepths = selection.selectionSet.selections.map((sel) => getDepthFromSelection(sel, currentDepth + 1));
+        return Math.max(...childDepths);
+    }
+    return currentDepth;
+}
+function getQueryDepth(info) {
+    return getDepthFromSelection(info.fieldNodes[0], 0);
+}
+const getQueryFields = (info) => {
+    return Object.fromEntries(Array.from((0, utils_1.collectFields)(info.schema, info.fragments, info.variableValues, {}, info.fieldNodes[0].selectionSet).fields.keys()).map((v) => [v, true]));
+};
+exports.getQueryFields = getQueryFields;
+const OperatorMap = {
+    eq: p.eq,
+    ne: p.ne,
+    gt: p.gt,
+    gte: p.gte,
+    lt: p.lt,
+    lte: p.lte,
+    like: p.like,
+    notLike: p.notLike,
+    ilike: p.ilike,
+    notIlike: p.notIlike,
+    isNull: p.isNull,
+    isNotNull: p.isNotNull,
+    in: p.inArray,
+    notIn: p.notInArray,
+    arrayContained: p.arrayContained,
+    arrayOverlaps: p.arrayOverlaps,
+    arrayContains: p.arrayContains,
+};
+const createWhereQuery = (table, tree) => {
+    if (!tree)
+        return p.and();
+    const result = Object.entries(tree)
+        .map(([key, value]) => {
+        switch (key) {
+            case "AND":
+                return value.length
+                    ? p.and(...value.map((v) => (0, exports.createWhereQuery)(table, v)))
+                    : undefined;
+            case "OR":
+                return value.length
+                    ? p.or(...value.map((v) => (0, exports.createWhereQuery)(table, v)))
+                    : undefined;
+            case "NOT": {
+                const v = (0, exports.createWhereQuery)(table, value);
+                return v ? p.not(v) : undefined;
+            }
+        }
+        const result = Object.entries(value).map(([k, v]) => {
+            const m = OperatorMap[k];
+            return m(p.getColumns(table)[key], v);
+        });
+        if (result.length === 1) {
+            return result[0];
+        }
+        return p.and(...result);
+    })
+        .flatMap((v) => (v ? [v] : []));
+    if (result.length === 1)
+        return result[0];
+    return p.and(...result);
+};
+exports.createWhereQuery = createWhereQuery;
+const createInputOperator = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+builder, type) => {
+    const typeName = Array.isArray(type) ? `Array${type[0]}` : type;
+    const name = `${typeName}InputOperator`;
+    const inputType = builder.inputType(name, {
+        fields: (t) => ({
+            eq: t.field({ type }),
+            ne: t.field({ type }),
+            gt: t.field({ type }),
+            gte: t.field({ type }),
+            lt: t.field({ type }),
+            lte: t.field({ type }),
+            like: t.field({ type }),
+            notLike: t.field({ type }),
+            ilike: t.field({ type }),
+            notIlike: t.field({ type }),
+            isNull: t.boolean(),
+            isNotNull: t.boolean(),
+            in: t.field({ type: [type] }),
+            notIn: t.field({ type: [type] }),
+            arrayContained: t.field({ type: [type] }),
+            arrayOverlaps: t.field({ type: [type] }),
+            arrayContains: t.field({ type: [type] }),
+        }),
+    });
+    return inputType;
+};
+exports.createInputOperator = createInputOperator;
+const convertAggregationQuery = (query) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { aggregation, columns, ...q } = query;
+    const newQuery = aggregation ? { ...q, columns: {} } : query;
+    const newWith = query.with
+        ? Object.fromEntries(Object.entries(query.with).map(([key, value]) => [
+            key,
+            (0, exports.convertAggregationQuery)(value),
+        ]))
+        : query.with;
+    return { ...newQuery, with: newWith };
+};
+exports.convertAggregationQuery = convertAggregationQuery;

package/dist/esm/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;
+}