@contractspec/lib.schema 1.57.0 → 1.58.0

package/dist/node/entity/generator.js

@@ -0,0 +1,283 @@
+// src/entity/generator.ts
+function generatePrismaSchema(entities, options = {}) {
+  const {
+    provider = "postgresql",
+    clientOutput = "../../src/generated/prisma",
+    includePothos = true,
+    pothosOutput = "../../src/generated/pothos-types.ts"
+  } = options;
+  const lines = [];
+  const schemas = new Set;
+  entities.forEach((entity) => {
+    if (entity.schema) {
+      schemas.add(entity.schema);
+    }
+  });
+  const schemaList = schemas.size > 0 ? Array.from(schemas) : ["public"];
+  lines.push("datasource db {");
+  lines.push(`  provider = "${provider}"`);
+  if (schemas.size > 0) {
+    lines.push(`  schemas  = [${schemaList.map((s) => `"${s}"`).join(", ")}]`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("generator client {");
+  lines.push('  provider = "prisma-client"');
+  lines.push(`  output   = "${clientOutput}"`);
+  lines.push("");
+  lines.push('  engineType             = "client"');
+  lines.push('  runtime                = "bun"');
+  lines.push('  moduleFormat           = "esm"');
+  lines.push('  generatedFileExtension = "ts"');
+  lines.push('  importFileExtension    = "ts"');
+  lines.push("}");
+  lines.push("");
+  if (includePothos) {
+    lines.push("generator pothos {");
+    lines.push('  provider          = "prisma-pothos-types"');
+    lines.push('  clientOutput      = "./prisma"');
+    lines.push(`  output            = "${pothosOutput}"`);
+    lines.push("  generateDatamodel = true");
+    lines.push("  documentation     = false");
+    lines.push("}");
+    lines.push("");
+  }
+  const enumMap = new Map;
+  entities.forEach((entity) => {
+    entity.enums?.forEach((enumDef) => {
+      if (!enumMap.has(enumDef.name)) {
+        enumMap.set(enumDef.name, enumDef);
+      }
+    });
+    Object.values(entity.fields).forEach((field) => {
+      if (field.kind === "enum" && field.values && !enumMap.has(field.enumName)) {
+        enumMap.set(field.enumName, {
+          name: field.enumName,
+          values: field.values,
+          schema: entity.schema
+        });
+      }
+    });
+  });
+  enumMap.forEach((enumDef) => {
+    lines.push(...generateEnumBlock(enumDef));
+    lines.push("");
+  });
+  entities.forEach((entity) => {
+    lines.push(...generateModelBlock(entity));
+    lines.push("");
+  });
+  return lines.join(`
+`);
+}
+function generateEnumBlock(enumDef) {
+  const lines = [];
+  if (enumDef.description) {
+    lines.push(`/// ${enumDef.description}`);
+  }
+  lines.push(`enum ${enumDef.name} {`);
+  enumDef.values.forEach((value) => {
+    lines.push(`  ${value}`);
+  });
+  lines.push("");
+  if (enumDef.schema) {
+    lines.push(`  @@schema("${enumDef.schema}")`);
+  }
+  lines.push("}");
+  return lines;
+}
+function generateModelBlock(entity) {
+  const lines = [];
+  if (entity.description) {
+    lines.push(`/// ${entity.description}`);
+  }
+  lines.push(`model ${entity.name} {`);
+  Object.entries(entity.fields).forEach(([fieldName, field]) => {
+    const fieldLine = generateFieldLine(fieldName, field);
+    if (field.description) {
+      lines.push(`  /// ${field.description}`);
+    }
+    lines.push(`  ${fieldLine}`);
+  });
+  if (entity.indexes && entity.indexes.length > 0) {
+    lines.push("");
+    entity.indexes.forEach((idx) => {
+      lines.push(`  ${generateIndexLine(idx)}`);
+    });
+  }
+  if (entity.map) {
+    lines.push(`  @@map("${entity.map}")`);
+  }
+  if (entity.schema) {
+    lines.push(`  @@schema("${entity.schema}")`);
+  }
+  lines.push("}");
+  return lines;
+}
+function generateFieldLine(fieldName, field) {
+  if (field.kind === "scalar") {
+    return generateScalarFieldLine(fieldName, field);
+  } else if (field.kind === "enum") {
+    return generateEnumFieldLine(fieldName, field);
+  } else if (field.kind === "relation") {
+    return generateRelationFieldLine(fieldName, field);
+  }
+  throw new Error(`Unknown field kind: ${field.kind}`);
+}
+function generateScalarFieldLine(fieldName, field) {
+  const parts = [fieldName];
+  let typeStr = field.type;
+  if (field.isArray) {
+    typeStr += "[]";
+  }
+  if (field.isOptional) {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const attrs = [];
+  if (field.isId) {
+    attrs.push("@id");
+  }
+  if (field.default !== undefined) {
+    if (typeof field.default === "string" && field.default.includes("(")) {
+      attrs.push(`@default(${field.default})`);
+    } else if (typeof field.default === "boolean") {
+      attrs.push(`@default(${field.default})`);
+    } else if (typeof field.default === "number") {
+      attrs.push(`@default(${field.default})`);
+    } else {
+      attrs.push(`@default("${field.default}")`);
+    }
+  }
+  if (field.updatedAt) {
+    attrs.push("@updatedAt");
+  }
+  if (field.isUnique) {
+    attrs.push("@unique");
+  }
+  if (field.map) {
+    attrs.push(`@map("${field.map}")`);
+  }
+  if (field.dbType) {
+    attrs.push(`@db.${field.dbType}`);
+  }
+  if (attrs.length > 0) {
+    parts.push(attrs.join(" "));
+  }
+  return parts.join(" ");
+}
+function generateEnumFieldLine(fieldName, field) {
+  const parts = [fieldName];
+  let typeStr = field.enumName;
+  if (field.isArray) {
+    typeStr += "[]";
+  }
+  if (field.isOptional) {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const attrs = [];
+  if (field.default !== undefined) {
+    attrs.push(`@default(${field.default})`);
+  }
+  if (field.isUnique) {
+    attrs.push("@unique");
+  }
+  if (field.map) {
+    attrs.push(`@map("${field.map}")`);
+  }
+  if (attrs.length > 0) {
+    parts.push(attrs.join(" "));
+  }
+  return parts.join(" ");
+}
+function generateRelationFieldLine(fieldName, field) {
+  const parts = [fieldName];
+  let typeStr = field.target;
+  if (field.type === "hasMany") {
+    typeStr += "[]";
+  }
+  if (field.type === "hasOne") {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const relationParts = [];
+  if (field.name) {
+    relationParts.push(`name: "${field.name}"`);
+  }
+  if (field.fields && field.fields.length > 0) {
+    relationParts.push(`fields: [${field.fields.join(", ")}]`);
+  }
+  if (field.references && field.references.length > 0) {
+    relationParts.push(`references: [${field.references.join(", ")}]`);
+  }
+  if (field.onDelete) {
+    relationParts.push(`onDelete: ${field.onDelete}`);
+  }
+  if (field.onUpdate) {
+    relationParts.push(`onUpdate: ${field.onUpdate}`);
+  }
+  if (relationParts.length > 0) {
+    parts.push(`@relation(${relationParts.join(", ")})`);
+  }
+  return parts.join(" ");
+}
+function generateIndexLine(idx) {
+  const fieldList = idx.fields.join(", ");
+  const parts = [];
+  if (idx.unique) {
+    parts.push(`@@unique([${fieldList}]`);
+  } else {
+    parts.push(`@@index([${fieldList}]`);
+  }
+  const options = [];
+  if (idx.name) {
+    options.push(`name: "${idx.name}"`);
+  }
+  if (idx.type) {
+    options.push(`type: ${idx.type}`);
+  }
+  if (options.length > 0) {
+    parts[0] += `, ${options.join(", ")}`;
+  }
+  parts[0] += ")";
+  return parts.join("");
+}
+function composeModuleSchemas(contributions, options = {}) {
+  const allEntities = [];
+  const allEnums = new Map;
+  contributions.forEach((contrib) => {
+    contrib.entities.forEach((entity) => {
+      allEntities.push({
+        ...entity,
+        module: contrib.moduleId
+      });
+    });
+    contrib.enums?.forEach((enumDef) => {
+      if (!allEnums.has(enumDef.name)) {
+        allEnums.set(enumDef.name, enumDef);
+      }
+    });
+  });
+  if (allEntities[0] && allEnums.size > 0) {
+    allEntities[0] = {
+      ...allEntities[0],
+      enums: [...allEntities[0].enums ?? [], ...allEnums.values()]
+    };
+  }
+  return generatePrismaSchema(allEntities, options);
+}
+function generateEntityFragment(entity) {
+  return generateModelBlock(entity).join(`
+`);
+}
+function generateEnumFragment(enumDef) {
+  return generateEnumBlock(enumDef).join(`
+`);
+}
+export {
+  generatePrismaSchema,
+  generateEnumFragment,
+  generateEntityFragment,
+  composeModuleSchemas
+};

package/dist/node/entity/index.js

@@ -0,0 +1,410 @@
+// src/entity/defineEntity.ts
+import * as z from "zod";
+function defineEntity(spec) {
+  return spec;
+}
+function defineEntityEnum(def) {
+  return def;
+}
+var field = {
+  string(opts) {
+    return { kind: "scalar", type: "String", ...opts };
+  },
+  int(opts) {
+    return { kind: "scalar", type: "Int", ...opts };
+  },
+  float(opts) {
+    return { kind: "scalar", type: "Float", ...opts };
+  },
+  boolean(opts) {
+    return { kind: "scalar", type: "Boolean", ...opts };
+  },
+  dateTime(opts) {
+    return { kind: "scalar", type: "DateTime", ...opts };
+  },
+  json(opts) {
+    return { kind: "scalar", type: "Json", ...opts };
+  },
+  bigInt(opts) {
+    return { kind: "scalar", type: "BigInt", ...opts };
+  },
+  decimal(opts) {
+    return { kind: "scalar", type: "Decimal", ...opts };
+  },
+  bytes(opts) {
+    return { kind: "scalar", type: "Bytes", ...opts };
+  },
+  id(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      isId: true,
+      default: "cuid()",
+      ...opts
+    };
+  },
+  uuid(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      isId: true,
+      default: "uuid()",
+      ...opts
+    };
+  },
+  autoIncrement(opts) {
+    return {
+      kind: "scalar",
+      type: "Int",
+      isId: true,
+      default: "autoincrement()",
+      ...opts
+    };
+  },
+  createdAt(opts) {
+    return { kind: "scalar", type: "DateTime", default: "now()", ...opts };
+  },
+  updatedAt(opts) {
+    return { kind: "scalar", type: "DateTime", updatedAt: true, ...opts };
+  },
+  email(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      zod: z.email(),
+      ...opts
+    };
+  },
+  url(opts) {
+    return {
+      kind: "scalar",
+      type: "String",
+      zod: z.url(),
+      ...opts
+    };
+  },
+  enum(enumName, opts) {
+    return { kind: "enum", enumName, ...opts };
+  },
+  inlineEnum(enumName, values, opts) {
+    return { kind: "enum", enumName, values, ...opts };
+  },
+  hasOne(target, opts) {
+    return { kind: "relation", type: "hasOne", target, ...opts };
+  },
+  hasMany(target, opts) {
+    return { kind: "relation", type: "hasMany", target, ...opts };
+  },
+  belongsTo(target, fields, references, opts) {
+    return {
+      kind: "relation",
+      type: "belongsTo",
+      target,
+      fields,
+      references,
+      ...opts
+    };
+  },
+  foreignKey(opts) {
+    return { kind: "scalar", type: "String", ...opts };
+  }
+};
+var index = {
+  on(fields, opts) {
+    return { fields, ...opts };
+  },
+  unique(fields, opts) {
+    return { fields, unique: true, ...opts };
+  },
+  compound(fields, sort, opts) {
+    return { fields, sort, ...opts };
+  }
+};
+
+// src/entity/generator.ts
+function generatePrismaSchema(entities, options = {}) {
+  const {
+    provider = "postgresql",
+    clientOutput = "../../src/generated/prisma",
+    includePothos = true,
+    pothosOutput = "../../src/generated/pothos-types.ts"
+  } = options;
+  const lines = [];
+  const schemas = new Set;
+  entities.forEach((entity) => {
+    if (entity.schema) {
+      schemas.add(entity.schema);
+    }
+  });
+  const schemaList = schemas.size > 0 ? Array.from(schemas) : ["public"];
+  lines.push("datasource db {");
+  lines.push(`  provider = "${provider}"`);
+  if (schemas.size > 0) {
+    lines.push(`  schemas  = [${schemaList.map((s) => `"${s}"`).join(", ")}]`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("generator client {");
+  lines.push('  provider = "prisma-client"');
+  lines.push(`  output   = "${clientOutput}"`);
+  lines.push("");
+  lines.push('  engineType             = "client"');
+  lines.push('  runtime                = "bun"');
+  lines.push('  moduleFormat           = "esm"');
+  lines.push('  generatedFileExtension = "ts"');
+  lines.push('  importFileExtension    = "ts"');
+  lines.push("}");
+  lines.push("");
+  if (includePothos) {
+    lines.push("generator pothos {");
+    lines.push('  provider          = "prisma-pothos-types"');
+    lines.push('  clientOutput      = "./prisma"');
+    lines.push(`  output            = "${pothosOutput}"`);
+    lines.push("  generateDatamodel = true");
+    lines.push("  documentation     = false");
+    lines.push("}");
+    lines.push("");
+  }
+  const enumMap = new Map;
+  entities.forEach((entity) => {
+    entity.enums?.forEach((enumDef) => {
+      if (!enumMap.has(enumDef.name)) {
+        enumMap.set(enumDef.name, enumDef);
+      }
+    });
+    Object.values(entity.fields).forEach((field2) => {
+      if (field2.kind === "enum" && field2.values && !enumMap.has(field2.enumName)) {
+        enumMap.set(field2.enumName, {
+          name: field2.enumName,
+          values: field2.values,
+          schema: entity.schema
+        });
+      }
+    });
+  });
+  enumMap.forEach((enumDef) => {
+    lines.push(...generateEnumBlock(enumDef));
+    lines.push("");
+  });
+  entities.forEach((entity) => {
+    lines.push(...generateModelBlock(entity));
+    lines.push("");
+  });
+  return lines.join(`
+`);
+}
+function generateEnumBlock(enumDef) {
+  const lines = [];
+  if (enumDef.description) {
+    lines.push(`/// ${enumDef.description}`);
+  }
+  lines.push(`enum ${enumDef.name} {`);
+  enumDef.values.forEach((value) => {
+    lines.push(`  ${value}`);
+  });
+  lines.push("");
+  if (enumDef.schema) {
+    lines.push(`  @@schema("${enumDef.schema}")`);
+  }
+  lines.push("}");
+  return lines;
+}
+function generateModelBlock(entity) {
+  const lines = [];
+  if (entity.description) {
+    lines.push(`/// ${entity.description}`);
+  }
+  lines.push(`model ${entity.name} {`);
+  Object.entries(entity.fields).forEach(([fieldName, field2]) => {
+    const fieldLine = generateFieldLine(fieldName, field2);
+    if (field2.description) {
+      lines.push(`  /// ${field2.description}`);
+    }
+    lines.push(`  ${fieldLine}`);
+  });
+  if (entity.indexes && entity.indexes.length > 0) {
+    lines.push("");
+    entity.indexes.forEach((idx) => {
+      lines.push(`  ${generateIndexLine(idx)}`);
+    });
+  }
+  if (entity.map) {
+    lines.push(`  @@map("${entity.map}")`);
+  }
+  if (entity.schema) {
+    lines.push(`  @@schema("${entity.schema}")`);
+  }
+  lines.push("}");
+  return lines;
+}
+function generateFieldLine(fieldName, field2) {
+  if (field2.kind === "scalar") {
+    return generateScalarFieldLine(fieldName, field2);
+  } else if (field2.kind === "enum") {
+    return generateEnumFieldLine(fieldName, field2);
+  } else if (field2.kind === "relation") {
+    return generateRelationFieldLine(fieldName, field2);
+  }
+  throw new Error(`Unknown field kind: ${field2.kind}`);
+}
+function generateScalarFieldLine(fieldName, field2) {
+  const parts = [fieldName];
+  let typeStr = field2.type;
+  if (field2.isArray) {
+    typeStr += "[]";
+  }
+  if (field2.isOptional) {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const attrs = [];
+  if (field2.isId) {
+    attrs.push("@id");
+  }
+  if (field2.default !== undefined) {
+    if (typeof field2.default === "string" && field2.default.includes("(")) {
+      attrs.push(`@default(${field2.default})`);
+    } else if (typeof field2.default === "boolean") {
+      attrs.push(`@default(${field2.default})`);
+    } else if (typeof field2.default === "number") {
+      attrs.push(`@default(${field2.default})`);
+    } else {
+      attrs.push(`@default("${field2.default}")`);
+    }
+  }
+  if (field2.updatedAt) {
+    attrs.push("@updatedAt");
+  }
+  if (field2.isUnique) {
+    attrs.push("@unique");
+  }
+  if (field2.map) {
+    attrs.push(`@map("${field2.map}")`);
+  }
+  if (field2.dbType) {
+    attrs.push(`@db.${field2.dbType}`);
+  }
+  if (attrs.length > 0) {
+    parts.push(attrs.join(" "));
+  }
+  return parts.join(" ");
+}
+function generateEnumFieldLine(fieldName, field2) {
+  const parts = [fieldName];
+  let typeStr = field2.enumName;
+  if (field2.isArray) {
+    typeStr += "[]";
+  }
+  if (field2.isOptional) {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const attrs = [];
+  if (field2.default !== undefined) {
+    attrs.push(`@default(${field2.default})`);
+  }
+  if (field2.isUnique) {
+    attrs.push("@unique");
+  }
+  if (field2.map) {
+    attrs.push(`@map("${field2.map}")`);
+  }
+  if (attrs.length > 0) {
+    parts.push(attrs.join(" "));
+  }
+  return parts.join(" ");
+}
+function generateRelationFieldLine(fieldName, field2) {
+  const parts = [fieldName];
+  let typeStr = field2.target;
+  if (field2.type === "hasMany") {
+    typeStr += "[]";
+  }
+  if (field2.type === "hasOne") {
+    typeStr += "?";
+  }
+  parts.push(typeStr);
+  const relationParts = [];
+  if (field2.name) {
+    relationParts.push(`name: "${field2.name}"`);
+  }
+  if (field2.fields && field2.fields.length > 0) {
+    relationParts.push(`fields: [${field2.fields.join(", ")}]`);
+  }
+  if (field2.references && field2.references.length > 0) {
+    relationParts.push(`references: [${field2.references.join(", ")}]`);
+  }
+  if (field2.onDelete) {
+    relationParts.push(`onDelete: ${field2.onDelete}`);
+  }
+  if (field2.onUpdate) {
+    relationParts.push(`onUpdate: ${field2.onUpdate}`);
+  }
+  if (relationParts.length > 0) {
+    parts.push(`@relation(${relationParts.join(", ")})`);
+  }
+  return parts.join(" ");
+}
+function generateIndexLine(idx) {
+  const fieldList = idx.fields.join(", ");
+  const parts = [];
+  if (idx.unique) {
+    parts.push(`@@unique([${fieldList}]`);
+  } else {
+    parts.push(`@@index([${fieldList}]`);
+  }
+  const options = [];
+  if (idx.name) {
+    options.push(`name: "${idx.name}"`);
+  }
+  if (idx.type) {
+    options.push(`type: ${idx.type}`);
+  }
+  if (options.length > 0) {
+    parts[0] += `, ${options.join(", ")}`;
+  }
+  parts[0] += ")";
+  return parts.join("");
+}
+function composeModuleSchemas(contributions, options = {}) {
+  const allEntities = [];
+  const allEnums = new Map;
+  contributions.forEach((contrib) => {
+    contrib.entities.forEach((entity) => {
+      allEntities.push({
+        ...entity,
+        module: contrib.moduleId
+      });
+    });
+    contrib.enums?.forEach((enumDef) => {
+      if (!allEnums.has(enumDef.name)) {
+        allEnums.set(enumDef.name, enumDef);
+      }
+    });
+  });
+  if (allEntities[0] && allEnums.size > 0) {
+    allEntities[0] = {
+      ...allEntities[0],
+      enums: [...allEntities[0].enums ?? [], ...allEnums.values()]
+    };
+  }
+  return generatePrismaSchema(allEntities, options);
+}
+function generateEntityFragment(entity) {
+  return generateModelBlock(entity).join(`
+`);
+}
+function generateEnumFragment(enumDef) {
+  return generateEnumBlock(enumDef).join(`
+`);
+}
+export {
+  index,
+  generatePrismaSchema,
+  generateEnumFragment,
+  generateEntityFragment,
+  field,
+  defineEntityEnum,
+  defineEntity,
+  composeModuleSchemas
+};