pothos-drizzle-generator 0.0.1

package/dist/esm/PothosDrizzleGeneratorPlugin.js

@@ -0,0 +1,395 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BasePlugin } from "@pothos/core";
+import { sql } from "drizzle-orm";
+import { PothosDrizzleGenerator } from "./generator.js";
+import { createWhereQuery, getQueryDepth } from "./libs/utils.js";
+export class PothosDrizzleGeneratorPlugin extends BasePlugin {
+    generator;
+    constructor(buildCache, name) {
+        super(buildCache, name);
+        this.generator = new 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 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 &&
+                                    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 &&
+                                    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 &&
+                                    getQueryDepth(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx).query[modelName]
+                                    .findFirst({
+                                    columns: {},
+                                    extras: { _count: () => 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 &&
+                                    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 &&
+                                    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 &&
+                                    getQueryDepth(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx)
+                                    .update(table)
+                                    .set(args.input)
+                                    .where(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 &&
+                                    getQueryDepth(info) > p.depthLimit)
+                                    throw new Error("Depth limit exceeded");
+                                return generator.getClient(ctx)
+                                    .delete(table)
+                                    .where(createWhereQuery(table, {
+                                    AND: [args.where, p.where].filter((v) => v),
+                                }))
+                                    .returning();
+                            },
+                        }),
+                    }),
+                });
+            }
+        }
+    }
+}

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

package/dist/esm/generator.js

@@ -0,0 +1,227 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { isTable, } from "drizzle-orm";
+import { BigIntResolver, ByteResolver, DateResolver, DateTimeResolver, HexadecimalResolver, JSONResolver, } from "graphql-scalars";
+import { expandOperations, OperationBasic } from "./libs/operations.js";
+import { createInputOperator } from "./libs/utils.js";
+export 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) => isTable(t.table))
+            .map(({ name, table, relations }) => {
+            const tableInfo = getConfig(table);
+            const modelOptions = options?.models?.[name];
+            const columns = tableInfo.columns;
+            //Operations
+            const operationIncludes = expandOperations(modelOptions?.operations?.include ?? OperationBasic);
+            const operationExcludes = 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] ?? createInputOperator(this.builder, type);
+        this.inputOperators[typeName] = input;
+        return input;
+    }
+    createInputType() {
+        const builder = this.builder;
+        const scalars = [
+            ["BigInt", BigIntResolver],
+            ["Date", DateResolver],
+            ["Bytes", ByteResolver],
+            ["DateTime", DateTimeResolver],
+            ["Json", JSONResolver],
+            ["Decimal", 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;
+    }
+}