pothos-drizzle-generator 0.0.1

package/dist/esm/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/esm/global-types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+import SchemaBuilder from "@pothos/core";
+import { PothosDrizzleGeneratorPlugin } from "./PothosDrizzleGeneratorPlugin.js";
+export * from "./global-types.js";
+const pluginName = "pothosDrizzleGenerator";
+const allowPluginReRegistration = SchemaBuilder.allowPluginReRegistration;
+SchemaBuilder.allowPluginReRegistration = true;
+SchemaBuilder.registerPlugin(pluginName, PothosDrizzleGeneratorPlugin);
+SchemaBuilder.allowPluginReRegistration = allowPluginReRegistration;
+export default pluginName;

package/dist/esm/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/esm/libs/operations.js

@@ -0,0 +1,40 @@
+export const OperationFind = ["findFirst", "findMany"];
+export const OperationQuery = [...OperationFind, "count"];
+export const OperationCreate = ["createOne", "createMany"];
+export const OperationUpdate = ["update"];
+export const OperationDelete = ["delete"];
+export const OperationMutation = [
+    ...OperationCreate,
+    ...OperationUpdate,
+    ...OperationDelete,
+];
+export const OperationBasic = [
+    ...OperationQuery,
+    ...OperationMutation,
+];
+export const OperationAll = [
+    "find",
+    "update",
+    "delete",
+    "query",
+    "mutation",
+    ...OperationBasic,
+];
+export const expandOperations = (operations) => {
+    return operations.flatMap((v) => v === "all"
+        ? OperationBasic
+        : v === "find"
+            ? OperationFind
+            : v === "update"
+                ? OperationUpdate
+                : v === "delete"
+                    ? OperationDelete
+                    : v === "query"
+                        ? OperationQuery
+                        : v === "mutation"
+                            ? OperationMutation
+                            : [v]);
+};
+export const isOperation = (operations, operation) => {
+    return operations.includes(operation);
+};

package/dist/esm/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/esm/libs/utils.js

@@ -0,0 +1,108 @@
+import { collectFields } from "@graphql-tools/utils";
+import * as p from "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;
+}
+export function getQueryDepth(info) {
+    return getDepthFromSelection(info.fieldNodes[0], 0);
+}
+export const getQueryFields = (info) => {
+    return Object.fromEntries(Array.from(collectFields(info.schema, info.fragments, info.variableValues, {}, info.fieldNodes[0].selectionSet).fields.keys()).map((v) => [v, true]));
+};
+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,
+};
+export 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) => createWhereQuery(table, v)))
+                    : undefined;
+            case "OR":
+                return value.length
+                    ? p.or(...value.map((v) => createWhereQuery(table, v)))
+                    : undefined;
+            case "NOT": {
+                const v = 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);
+};
+export 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;
+};
+export 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,
+            convertAggregationQuery(value),
+        ]))
+        : query.with;
+    return { ...newQuery, with: newWith };
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/eslint.config.mjs

@@ -0,0 +1,43 @@
+import eslint from "@eslint/js";
+import eslintConfigPrettier from "eslint-config-prettier";
+import importPlugin from "eslint-plugin-import";
+import tslint from "typescript-eslint";
+
+export default [
+  eslint.configs.recommended,
+  ...tslint.configs.recommended,
+  eslintConfigPrettier,
+  {
+    ignores: ["**/global-types.ts"],
+  },
+  {
+    plugins: {
+      import: importPlugin,
+    },
+    rules: {
+      "@typescript-eslint/no-unused-vars": "warn",
+      "no-empty-pattern": 0,
+      "no-empty": 0,
+
+      "import/order": [
+        "warn",
+        {
+          groups: [
+            "builtin",
+            "external",
+            "internal",
+            ["parent", "sibling"],
+            "object",
+            "type",
+            "index",
+          ],
+          pathGroupsExcludedImportTypes: ["builtin"],
+          alphabetize: {
+            order: "asc",
+            caseInsensitive: true,
+          },
+        },
+      ],
+    },
+  },
+];

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "pothos-drizzle-generator",
+  "version": "0.0.1",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc && tsc -p ./tsconfig.esm.json && cpy esm dist",
+    "watch": "tsc -b -w",
+    "lint": "eslint ./src",
+    "lint:fix": "eslint --fix ./src"
+  },
+  "dependencies": {
+    "@graphql-tools/utils": "10.11.0",
+    "@pothos/core": "4.10.0",
+    "@pothos/plugin-drizzle": "0.16.0",
+    "drizzle-orm": "1.0.0-beta.2-f9236e3",
+    "graphql": "16.12.0",
+    "graphql-scalars": "1.25.0"
+  },
+  "devDependencies": {
+    "@types/graphql": "14.5.0",
+    "@eslint/js": "9.39.2",
+    "eslint": "9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "^8.49.0",
+    "cpy-cli": "^6.0.0"
+  },
+  "repository": "https://github.com/node-libraries/pothos-drizzle-generator",
+  "author": "SoraKumo <info@croud.jp>",
+  "license": "MIT"
+}