@kiki.im.dev/zenstack-fetch/index.js

Generate fetch function from ZModel schema file of ZenStack with ofetch

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.name = void 0;
const ast_1 = require("@zenstackhq/sdk/ast");
const promises_1 = require("fs/promises");
const fs_1 = require("fs");
const change_case_1 = require("./utils/change-case");
const use_prisma_1 = require("./utils/use-prisma");
exports.name = "ZenStack Fetch";
function run(model, options) {
    return __awaiter(this, void 0, void 0, function* () {
        const DIR = (options === null || options === void 0 ? void 0 : options.dir) || "lib/prisma";
        const isDirExists = (0, fs_1.existsSync)(DIR);
        if (isDirExists)
            yield (0, promises_1.rm)(DIR, {
                recursive: true,
            });
        yield (0, promises_1.mkdir)(DIR, { recursive: true });
        yield (0, promises_1.mkdir)(`${DIR}/utils`);
        yield (0, promises_1.cp)(`${__dirname}/utils/use-prisma.ts`, `${DIR}/utils/use-prisma.ts`);
        // get all data models
        const dataModels = model.declarations.filter((x) => (0, ast_1.isDataModel)(x));
        for (const model of dataModels) {
            const modelName = model.name;
            const camelCaseModelName = (0, change_case_1.toCamelCase)(modelName);
            yield (0, promises_1.writeFile)(`${DIR}/${camelCaseModelName}.ts`, `import { Prisma } from "@prisma/client"
import { type PrismaClient } from "@zenstackhq/runtime"
import { usePrisma } from "./utils/use-prisma"

${createOperationTypes(model)}

${createFn(model)}
`);
        }
        yield (0, promises_1.writeFile)(`${DIR}/index.ts`, createImportIndex(dataModels));
    });
}
exports.default = run;
function createImportIndex(models) {
    const importType = (model) => use_prisma_1.operations
        .map((operation) => {
        const modelName = model.name;
        // const camelCaseModelName = toCamelCase(modelName)
        const pascalCaseOperation = (0, change_case_1.toPascalCase)(operation);
        const withOutput = ![
            "updateMany",
            "deleteMany",
            "aggregate",
            "count",
        ].includes(operation);
        const inputImport = `  type ${pascalCaseOperation}${modelName}Input,`;
        const outputImport = withOutput
            ? `\n type ${pascalCaseOperation}${modelName}Output,`
            : "";
        return `${inputImport}${outputImport}`;
    })
        .join("\n");
    const importFn = (model) => use_prisma_1.operations
        .map((operation) => {
        const modelName = model.name;
        // const camelCaseModelName = toCamelCase(model.name)
        // const pascalCaseOperation = toPascalCase(operation)
        return `  ${operation}${modelName},`;
    })
        .join("\n");
    const imports = models
        .map((model) => {
        const modelName = model.name;
        const camelCaseModelName = (0, change_case_1.toCamelCase)(modelName);
        return `export {
${importType(model)}
${importFn(model)}
} from "./${camelCaseModelName}"`;
    })
        .join("\n\n");
    return `export { usePrisma } from "./utils/use-prisma"
${imports}
`;
}
function createOperationTypes(model) {
    return use_prisma_1.operations
        .map((operation) => {
        const modelName = model.name;
        const camelCaseModelName = (0, change_case_1.toCamelCase)(model.name);
        const pascalCaseOperation = (0, change_case_1.toPascalCase)(operation);
        const withOutput = ![
            "updateMany",
            "deleteMany",
            "aggregate",
            "count",
        ].includes(operation);
        const inputType = `export type ${pascalCaseOperation}${modelName}Input = Prisma.Args<PrismaClient["${camelCaseModelName}"], "${operation}">`;
        const outputType = withOutput
            ? `\nexport type ${pascalCaseOperation}${modelName}Output<I extends ${pascalCaseOperation}${modelName}Input> = Prisma.${modelName}GetPayload<I>`
            : "";
        return `${inputType} ${outputType}`;
    })
        .join("\n");
}
function createFn(model) {
    return use_prisma_1.operations
        .map((operation) => {
        const modelName = model.name;
        const camelCaseModelName = (0, change_case_1.toCamelCase)(model.name);
        const pascalCaseOperation = (0, change_case_1.toPascalCase)(operation);
        return `export const ${operation}${modelName} = <T extends ${pascalCaseOperation}${modelName}Input> (
  input?: MaybeRef<Prisma.Exact<T, ${pascalCaseOperation}${modelName}Input>>
) =>
  usePrisma({
    model: "${camelCaseModelName}",
    operation: "${operation}",
    input,
  })
`;
    })
        .join("\n");
}
//# sourceMappingURL=index.js.map