prisma-zero 0.1.0-canary.0

package/dist/generator.cjs

@@ -0,0 +1,563 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  onGenerate: () => onGenerate
+});
+module.exports = __toCommonJS(generator_exports);
+var import_generator_helper = __toESM(require("@prisma/generator-helper"), 1);
+var import_promises = require("fs/promises");
+var import_path = require("path");
+
+// package.json
+var version = "0.1.0-canary.0";
+
+// src/generators/code-generator.ts
+function generateImports(schema) {
+  const usedImports = /* @__PURE__ */ new Set();
+  usedImports.add("table");
+  usedImports.add("createSchema");
+  usedImports.add("createBuilder");
+  usedImports.add("createCRUDBuilder");
+  schema.models.forEach((model) => {
+    Object.values(model.columns).forEach((mapping) => {
+      const baseType = mapping.type.split("(")[0];
+      if (baseType) {
+        usedImports.add(baseType);
+      }
+    });
+    if (model.relationships && Object.keys(model.relationships).length > 0) {
+      usedImports.add("relationships");
+    }
+  });
+  const sortedImports = Array.from(usedImports).sort();
+  return `import {
+  ${sortedImports.join(",\n  ")},
+} from "@rocicorp/zero";
+
+`;
+}
+function generateUnionTypes(schema) {
+  if (schema.enums.length === 0) return "";
+  let output = "";
+  schema.enums.forEach((enumType) => {
+    output += `export type ${enumType.name} = `;
+    const values = enumType.values.map((value) => {
+      const enumValue = value.dbName || value.name;
+      return `"${enumValue}"`;
+    });
+    output += values.join(" | ");
+    output += ";\n\n";
+  });
+  return output;
+}
+function generateColumnDefinition(name, mapping) {
+  let typeStr = mapping.type;
+  if (mapping.mappedName) {
+    typeStr += `.from('${mapping.mappedName}')`;
+  }
+  if (mapping.isOptional) {
+    typeStr += `.optional()`;
+  }
+  return `    ${name}: ${typeStr}`;
+}
+function generateModelSchema(model) {
+  let output = `export const ${model.zeroTableName} = table("${model.tableName}")`;
+  if (model.originalTableName) {
+    output += `
+  .from("${model.originalTableName}")`;
+  }
+  output += "\n  .columns({\n";
+  Object.entries(model.columns).forEach(([name, mapping]) => {
+    output += generateColumnDefinition(name, mapping) + ",\n";
+  });
+  output += "  })";
+  output += `
+  .primaryKey(${model.primaryKey.map((key) => `"${key}"`).join(", ")});
+
+`;
+  return output;
+}
+function generateRelationshipConfig(rel) {
+  if ("chain" in rel) {
+    return rel.chain.map(
+      (link) => `{
+    sourceField: ${JSON.stringify(link.sourceField)},
+    destField: ${JSON.stringify(link.destField)},
+    destSchema: ${link.destSchema},
+  }`
+    ).join(", ");
+  } else {
+    return `{
+    sourceField: ${JSON.stringify(rel.sourceField)},
+    destField: ${JSON.stringify(rel.destField)},
+    destSchema: ${rel.destSchema},
+  }`;
+  }
+}
+function generateRelationships(models) {
+  const modelRelationships = models.map((model) => {
+    if (!model.relationships) return "";
+    const relationshipEntries = Object.entries(model.relationships);
+    if (relationshipEntries.length === 0) return "";
+    const hasOneRelation = relationshipEntries.some(
+      ([, rel]) => rel.type === "one"
+    );
+    const hasManyRelation = relationshipEntries.some(
+      ([, rel]) => rel.type === "many"
+    );
+    const relationshipImports = [];
+    if (hasOneRelation) relationshipImports.push("one");
+    if (hasManyRelation) relationshipImports.push("many");
+    const relationshipsStr = relationshipEntries.map(([name, rel]) => {
+      const configStr = generateRelationshipConfig(rel);
+      return `  ${name}: ${rel.type}(${configStr})`;
+    }).join(",\n");
+    return `export const ${model.zeroTableName}Relationships = relationships(${model.zeroTableName}, ({ ${relationshipImports.join(", ")} }) => ({
+${relationshipsStr}
+}));
+`;
+  });
+  const filteredRelationships = modelRelationships.filter(Boolean);
+  return filteredRelationships.length > 0 ? filteredRelationships.join("") : "";
+}
+function generateSchema(schema) {
+  let output = "/**\n";
+  output += " * The Zero schema object.\n";
+  output += " * This type is auto-generated from your Prisma schema definition.\n";
+  output += " */\n";
+  output += "export const schema = createSchema({\n";
+  output += "  tables: [\n";
+  schema.models.forEach((model) => {
+    output += `    ${model.zeroTableName},
+`;
+  });
+  output += "  ],\n";
+  const hasRelationships = schema.models.some(
+    (model) => model.relationships && Object.keys(model.relationships).length > 0
+  );
+  if (hasRelationships) {
+    output += "  relationships: [\n";
+    schema.models.forEach((model) => {
+      if (model.relationships && Object.keys(model.relationships).length > 0) {
+        output += `    ${model.zeroTableName}Relationships,
+`;
+      }
+    });
+    output += "  ],\n";
+  }
+  output += "});\n\n";
+  output += "/**\n";
+  output += " * Represents the Zero schema type.\n";
+  output += " * This type is auto-generated from your Prisma schema definition.\n";
+  output += " */\n";
+  output += "export type Schema = typeof schema;\n";
+  output += "/**\n";
+  output += " * Represents the ZQL query builder.\n";
+  output += " * This type is auto-generated from your Prisma schema definition.\n";
+  output += " */\n";
+  output += "export const zql = createBuilder(schema);\n";
+  output += "/**\n";
+  output += " * Represents the Zero schema query builder.\n";
+  output += " * This type is auto-generated from your Prisma schema definition.\n";
+  output += " *\n";
+  output += " * @deprecated Use `zql` instead.\n";
+  output += " */\n";
+  output += "export const builder = zql;\n";
+  output += "/**\n";
+  output += " * Represents the Zero schema CRUD builder.\n";
+  output += " * This type is auto-generated from your Prisma schema definition.\n";
+  output += " */\n";
+  output += "export const crud = createCRUDBuilder(schema);\n";
+  output += "/** Defines the default types for Zero */\n";
+  output += 'declare module "@rocicorp/zero" {\n';
+  output += "  interface DefaultTypes {\n";
+  output += "    schema: Schema;\n";
+  output += "  }\n";
+  output += "}\n";
+  return output;
+}
+function generateCode(schema) {
+  let output = `${HEADER_PREFIX}
+
+`;
+  output += generateImports(schema);
+  output += generateUnionTypes(schema);
+  schema.models.forEach((model) => {
+    output += generateModelSchema(model);
+  });
+  output += generateRelationships(schema.models);
+  output += generateSchema(schema);
+  return output;
+}
+var HEADER_PREFIX = `// This file was automatically generated by prisma-zero.
+// You should NOT make any changes in this file as it will be overwritten.`;
+
+// src/mappers/type-mapper.ts
+var TYPE_MAP = {
+  String: "string()",
+  Boolean: "boolean()",
+  Int: "number()",
+  Float: "number()",
+  DateTime: "number()",
+  // Zero uses timestamps
+  Json: "json()",
+  BigInt: "number()",
+  Decimal: "number()"
+};
+function mapPrismaTypeToZero(field) {
+  const isOptional = !field.isRequired;
+  const mappedName = field.dbName && field.dbName !== field.name ? field.dbName : null;
+  if (field.isList) {
+    const tsTypeMap = {
+      String: "string[]",
+      Boolean: "boolean[]",
+      Int: "number[]",
+      Float: "number[]",
+      DateTime: "number[]",
+      Json: "any[]",
+      BigInt: "number[]",
+      Decimal: "number[]"
+    };
+    const tsType = field.kind === "enum" ? `${field.type}[]` : tsTypeMap[field.type] || "any[]";
+    return {
+      type: `json<${tsType}>()`,
+      isOptional,
+      mappedName
+    };
+  }
+  if (field.kind === "enum") {
+    return {
+      type: `enumeration<${field.type}>()`,
+      isOptional,
+      mappedName
+    };
+  }
+  const baseType = TYPE_MAP[field.type] || "string()";
+  return {
+    type: baseType,
+    isOptional,
+    mappedName
+  };
+}
+
+// src/mappers/schema-mapper.ts
+var import_camelcase = __toESM(require("camelcase"), 1);
+function getTableNameFromModel(model) {
+  return model.dbName || model.name;
+}
+function getZeroTableName(str) {
+  const tableName = getTableName(str, { camelCase: true });
+  return tableName + "Table";
+}
+function ensureStringArray(arr) {
+  return Array.from(arr).filter((item) => item !== void 0);
+}
+function getImplicitManyToManyTableName(model1, model2, relationName) {
+  if (relationName) {
+    return `_${relationName}`;
+  }
+  const [first, second] = [model1, model2].sort();
+  return `_${first}To${second}`;
+}
+function toCamelCase(str) {
+  const prefixMatch = str.match(/^_+/);
+  const prefix = prefixMatch ? prefixMatch[0] : "";
+  const rest = str.slice(prefix.length);
+  return prefix + (0, import_camelcase.default)(rest);
+}
+function getTableName(tableName, config) {
+  if (config == null ? void 0 : config.camelCase) {
+    return toCamelCase(tableName);
+  }
+  return tableName;
+}
+function createImplicitManyToManyModel(model1, model2, relationName, config) {
+  const originalTableName = getImplicitManyToManyTableName(
+    model1.name,
+    model2.name,
+    relationName
+  );
+  const [modelA, modelB] = [model1, model2].sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+  if (!modelA || !modelB) {
+    throw new Error(
+      `Implicit relation ${relationName}: Model ${(modelA == null ? void 0 : modelA.name) ?? "unknown"} or ${(modelB == null ? void 0 : modelB.name) ?? "unknown"} not found.`
+    );
+  }
+  const tableName = getTableName(originalTableName, config);
+  const idFieldA = modelA.fields.find((f) => f.isId);
+  const idFieldB = modelB.fields.find((f) => f.isId);
+  if (!idFieldA) {
+    throw new Error(
+      `Implicit relation ${relationName}: Model ${modelA.name} has no @id field.`
+    );
+  }
+  if (!idFieldB) {
+    throw new Error(
+      `Implicit relation ${relationName}: Model ${modelB.name} has no @id field.`
+    );
+  }
+  const columnAType = mapPrismaTypeToZero(idFieldA);
+  const columnBType = mapPrismaTypeToZero(idFieldB);
+  return {
+    tableName,
+    originalTableName,
+    modelName: originalTableName,
+    zeroTableName: getZeroTableName(originalTableName),
+    columns: {
+      A: columnAType,
+      B: columnBType
+    },
+    relationships: {
+      modelA: {
+        sourceField: ["A"],
+        destField: [idFieldA.name],
+        destSchema: getZeroTableName(modelA.name),
+        type: "one"
+      },
+      modelB: {
+        sourceField: ["B"],
+        destField: [idFieldB.name],
+        destSchema: getZeroTableName(modelB.name),
+        type: "one"
+      }
+    },
+    primaryKey: ["A", "B"]
+  };
+}
+function mapRelationships(model, dmmf, config) {
+  const relationships = {};
+  model.fields.filter((field) => field.relationName).forEach((field) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const targetModel = dmmf.datamodel.models.find(
+      (m) => m.name === field.type
+    );
+    if (!targetModel) {
+      throw new Error(
+        `Target model ${field.type} not found for relationship ${field.name}`
+      );
+    }
+    if ((_a = config.excludeTables) == null ? void 0 : _a.includes(targetModel.name)) {
+      return;
+    }
+    const backReference = targetModel.fields.find(
+      (f) => f.relationName === field.relationName && f.type === model.name
+    );
+    if (field.isList) {
+      if (backReference == null ? void 0 : backReference.isList) {
+        const joinTableName = getImplicitManyToManyTableName(
+          model.name,
+          targetModel.name,
+          field.relationName
+        );
+        const [modelA] = [model, targetModel].sort(
+          (a, b) => a.name.localeCompare(b.name)
+        );
+        if (!modelA) {
+          throw new Error(
+            `Implicit relation ${field.name}: Model ${model.name} or ${targetModel.name} not found.`
+          );
+        }
+        const isModelA = model.name === modelA.name;
+        relationships[field.name] = {
+          type: "many",
+          chain: [
+            {
+              sourceField: [((_b = model.fields.find((f) => f.isId)) == null ? void 0 : _b.name) || "id"],
+              destField: [isModelA ? "A" : "B"],
+              destSchema: getZeroTableName(joinTableName)
+            },
+            {
+              sourceField: [isModelA ? "B" : "A"],
+              destField: [((_c = targetModel.fields.find((f) => f.isId)) == null ? void 0 : _c.name) || "id"],
+              destSchema: getZeroTableName(targetModel.name)
+            }
+          ]
+        };
+      } else {
+        const idField = (_d = model.fields.find((f) => f.isId)) == null ? void 0 : _d.name;
+        const primaryKeyFields = ((_e = model.primaryKey) == null ? void 0 : _e.fields) || (idField ? [idField] : []);
+        const sourceFields = ensureStringArray(primaryKeyFields);
+        const destFields = (backReference == null ? void 0 : backReference.relationFromFields) ? ensureStringArray(backReference.relationFromFields) : [];
+        relationships[field.name] = {
+          sourceField: sourceFields,
+          destField: destFields,
+          destSchema: getZeroTableName(targetModel.name),
+          type: "many"
+        };
+      }
+    } else {
+      let sourceFields = [];
+      let destFields = [];
+      if ((_f = field.relationFromFields) == null ? void 0 : _f.length) {
+        sourceFields = ensureStringArray(field.relationFromFields);
+        destFields = field.relationToFields ? ensureStringArray(field.relationToFields) : [];
+      } else if ((_g = backReference == null ? void 0 : backReference.relationFromFields) == null ? void 0 : _g.length) {
+        sourceFields = backReference.relationToFields ? ensureStringArray(backReference.relationToFields) : [];
+        destFields = ensureStringArray(backReference.relationFromFields);
+      }
+      relationships[field.name] = {
+        sourceField: sourceFields,
+        destField: destFields,
+        destSchema: getZeroTableName(targetModel.name),
+        type: "one"
+      };
+    }
+  });
+  return relationships;
+}
+function mapModel(model, dmmf, config) {
+  var _a, _b;
+  const columns = {};
+  model.fields.filter((field) => !field.relationName).forEach((field) => {
+    columns[field.name] = mapPrismaTypeToZero(field);
+  });
+  const idField = (_a = model.fields.find((f) => f.isId)) == null ? void 0 : _a.name;
+  const primaryKey = ((_b = model.primaryKey) == null ? void 0 : _b.fields) || (idField ? [idField] : []);
+  if (!primaryKey[0]) {
+    throw new Error(`No primary key found for ${model.name}`);
+  }
+  const tableName = getTableNameFromModel(model);
+  const camelCasedName = (config == null ? void 0 : config.camelCase) ? toCamelCase(tableName) : tableName;
+  const shouldRemap = config.camelCase && camelCasedName !== tableName;
+  return {
+    tableName: shouldRemap ? camelCasedName : tableName,
+    originalTableName: shouldRemap ? tableName : null,
+    modelName: model.name,
+    zeroTableName: getZeroTableName(model.name),
+    columns,
+    relationships: mapRelationships(model, dmmf, config),
+    primaryKey: ensureStringArray(primaryKey)
+  };
+}
+function transformSchema(dmmf, config) {
+  const filteredModels = dmmf.datamodel.models.filter((model) => {
+    var _a;
+    return !((_a = config.excludeTables) == null ? void 0 : _a.includes(model.name));
+  });
+  const models = filteredModels.map((model) => mapModel(model, dmmf, config));
+  const implicitJoinTables = filteredModels.flatMap((model) => {
+    return model.fields.filter((field) => field.relationName && field.isList).map((field) => {
+      var _a;
+      const targetModel = dmmf.datamodel.models.find(
+        (m) => m.name === field.type
+      );
+      if (!targetModel) return null;
+      if ((_a = config.excludeTables) == null ? void 0 : _a.includes(targetModel.name)) return null;
+      const backReference = targetModel.fields.find(
+        (f) => f.relationName === field.relationName && f.type === model.name
+      );
+      if (backReference == null ? void 0 : backReference.isList) {
+        if (model.name.localeCompare(targetModel.name) < 0) {
+          return createImplicitManyToManyModel(
+            model,
+            targetModel,
+            field.relationName,
+            config
+          );
+        }
+      }
+      return null;
+    }).filter((table) => table !== null);
+  });
+  return {
+    models: [...models, ...implicitJoinTables],
+    enums: [...dmmf.datamodel.enums]
+  };
+}
+
+// src/generator.ts
+var { generatorHandler } = import_generator_helper.default;
+async function onGenerate(options) {
+  var _a;
+  const { generator, dmmf } = options;
+  const outputFile = "schema.ts";
+  const outputDir = (_a = generator.output) == null ? void 0 : _a.value;
+  if (!outputDir) {
+    throw new Error("Output directory is required");
+  }
+  const config = {
+    name: generator.name,
+    prettier: generator.config.prettier === "true",
+    // Default false,
+    resolvePrettierConfig: generator.config.resolvePrettierConfig !== "false",
+    // Default true
+    camelCase: generator.config.camelCase === "true",
+    // Default false
+    excludeTables: loadExcludeTables(generator)
+  };
+  const transformedSchema = transformSchema(dmmf, config);
+  let output = generateCode(transformedSchema);
+  if (config.prettier) {
+    let prettier;
+    try {
+      prettier = await import("prettier");
+    } catch {
+      throw new Error(
+        "\u26A0\uFE0F  prisma-zero: prettier could not be found. Install it locally with\n  npm i -D prettier"
+      );
+    }
+    const prettierOptions = config.resolvePrettierConfig ? await prettier.resolveConfig(outputFile) : null;
+    output = await prettier.format(output, {
+      ...prettierOptions,
+      parser: "typescript"
+    });
+  }
+  await (0, import_promises.mkdir)(outputDir, { recursive: true });
+  await (0, import_promises.writeFile)((0, import_path.join)(outputDir, outputFile), output);
+}
+generatorHandler({
+  onManifest() {
+    return {
+      version,
+      defaultOutput: "generated/zero",
+      prettyName: "Zero Schema"
+    };
+  },
+  onGenerate
+});
+function loadExcludeTables(generator) {
+  const value = generator.config.excludeTables;
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("excludeTables must be an array");
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onGenerate
+});

package/dist/generator.d.cts

@@ -0,0 +1,5 @@
+import { GeneratorOptions } from '@prisma/generator-helper';
+
+declare function onGenerate(options: GeneratorOptions): Promise<void>;
+
+export { onGenerate };

package/dist/generator.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorOptions } from '@prisma/generator-helper';
+
+declare function onGenerate(options: GeneratorOptions): Promise<void>;
+
+export { onGenerate };