@vibeorm/dsl 2.0.0-alpha.6 → 2.0.0-alpha.8

package/dist/index.js

@@ -8,7 +8,8 @@ function cloneColumnDef(params) {
     __name: column.__name,
     __config: { ...column.__config },
     __enumValues: column.__enumValues,
-    __enumName: column.__enumName
+    __enumName: column.__enumName,
+    __enumStorage: column.__enumStorage
   };
 }
 
@@ -19,6 +20,7 @@ class ChainableColumn {
   __name;
   __enumValues;
   __enumName;
+  __enumStorage;
   constructor(columnType, config = {}) {
     this.__columnType = columnType;
     this.__config = { ...config };
@@ -69,6 +71,10 @@ class ChainableStringColumn extends ChainableColumn {
     this.__config.text = true;
     return this;
   }
+  collation(name) {
+    this.__config.collation = name;
+    return this;
+  }
 }
 
 class ChainableDecimalColumn extends ChainableColumn {
@@ -119,6 +125,9 @@ class ChainableEnumColumn extends ChainableColumn {
     if (params.enumName !== undefined) {
       this.__enumName = params.enumName;
     }
+    if (params.storage !== undefined) {
+      this.__enumStorage = params.storage;
+    }
   }
   default(value) {
     this.__config.default = value;
@@ -180,25 +189,35 @@ function extensionType(config) {
   });
 }
 function enumCol(config) {
-  const { options, ...restConfig } = config;
-  return new ChainableEnumColumn({ options, config: restConfig });
+  const { options, storage, ...restConfig } = config;
+  return new ChainableEnumColumn({
+    options,
+    config: restConfig,
+    ...storage === undefined ? {} : { storage }
+  });
 }
 
 // packages/dsl/src/enum.ts
+function enumValuesOf(params) {
+  const entries = Object.fromEntries(params.options.map((option) => [option, option]));
+  return Object.freeze(entries);
+}
 function createEnum(config) {
-  const { name, options } = config;
+  const { name, options, storage = "database" } = config;
   return {
     __type: "enum",
     __name: name,
     __options: options,
+    __storage: storage,
+    values: enumValuesOf({ options }),
     field(fieldConfig = {}) {
-      return new ChainableEnumColumn({ options, config: fieldConfig, enumName: name });
+      return new ChainableEnumColumn({ options, config: fieldConfig, enumName: name, storage });
     }
   };
 }
 
 // packages/dsl/src/generator/prisma.ts
-import { internalError } from "@vibeorm/schema";
+import { VibeError, encodePrismaString, internalError } from "@vibeorm/schema";
 
 // packages/dsl/src/naming.ts
 function capitalize(params) {
@@ -320,7 +339,9 @@ function create(config) {
     __map: config.map,
     __primaryKey: config.primaryKey,
     __checks: config.checks,
-    __extensions: config.extensions
+    __extensions: config.extensions,
+    __policy: config.policy,
+    __comment: config.comment
   };
 }
 function getColumnNames(params) {
@@ -640,7 +661,7 @@ function prismaType(params) {
         const args = Array.isArray(rawArgs) ? rawArgs.map(String).join(", ") : "";
         return `${extensionTypeName}${args.length > 0 ? `(${args})` : ""}${list}`;
       }
-      return `Unsupported("${String(column.__config.dbType)}")${list}`;
+      return `Unsupported(${encodePrismaString({ value: String(column.__config.dbType) })})${list}`;
     }
   }
 }
@@ -661,7 +682,7 @@ function defaultAttribute(params) {
   const { column } = params;
   const { dbgenerated, default: value } = column.__config;
   if (typeof dbgenerated === "string") {
-    return `@default(dbgenerated("${dbgenerated}"))`;
+    return `@default(dbgenerated(${encodePrismaString({ value: dbgenerated })}))`;
   }
   if (value === undefined)
     return;
@@ -672,7 +693,7 @@ function defaultAttribute(params) {
     return `@default(${value})`;
   }
   if (typeof value === "string")
-    return `@default("${value}")`;
+    return `@default(${encodePrismaString({ value })})`;
   if (typeof value === "boolean" || typeof value === "number")
     return `@default(${value})`;
   if (typeof value === "bigint")
@@ -720,11 +741,14 @@ function formatColumn(params) {
     parts.push("@unique");
   }
   if (typeof column.__config.map === "string") {
-    parts.push(`@map("${column.__config.map}")`);
+    parts.push(`@map(${encodePrismaString({ value: column.__config.map })})`);
   }
   const nativeType = nativeTypeAttribute({ column });
   if (nativeType !== undefined)
     parts.push(nativeType);
+  if (typeof column.__config.collation === "string") {
+    parts.push(`@collation(${encodePrismaString({ value: column.__config.collation })})`);
+  }
   const columnLine = parts.join(" ");
   const comment = column.__config.comment;
   if (typeof comment === "string") {
@@ -739,17 +763,17 @@ function formatRelation(params) {
   const { relation } = params;
   const { name, targetModel, relationName } = relation;
   if (relation.kind === "list") {
-    const attribute = relationName === undefined ? "" : ` @relation("${relationName}")`;
+    const attribute = relationName === undefined ? "" : ` @relation(${encodePrismaString({ value: relationName })})`;
     return `  ${name} ${targetModel}[]${attribute}`;
   }
   const optional = relation.isOptional ? "?" : "";
   if (relation.kind === "backOne") {
-    const attribute = relationName === undefined ? "" : ` @relation("${relationName}")`;
+    const attribute = relationName === undefined ? "" : ` @relation(${encodePrismaString({ value: relationName })})`;
     return `  ${name} ${targetModel}${optional}${attribute}`;
   }
   const args = [];
   if (relationName !== undefined)
-    args.push(`"${relationName}"`);
+    args.push(encodePrismaString({ value: relationName }));
   if (relation.fields === undefined || relation.references === undefined) {
     throw internalError({
       message: `planned FK relation "${relation.model}.${name}" has no fields/references`,
@@ -767,9 +791,9 @@ function formatRelation(params) {
 function formatIndex(params) {
   const { index } = params;
   const columns = index.columns.join(", ");
-  const whereArg = index.where === undefined ? "" : `, where: ${JSON.stringify(index.where)}`;
+  const whereArg = index.where === undefined ? "" : `, where: ${encodePrismaString({ value: index.where })}`;
   const nndArg = index.nullsNotDistinct === true ? ", nullsNotDistinct: true" : "";
-  const nameArg = index.clientName === undefined ? "" : `, name: ${JSON.stringify(index.clientName)}`;
+  const nameArg = index.clientName === undefined ? "" : `, name: ${encodePrismaString({ value: index.clientName })}`;
   if (index.isUnique) {
     return `  @@unique([${columns}]${nameArg}${nndArg}${whereArg})`;
   }
@@ -779,7 +803,7 @@ function formatIndex(params) {
 function formatExtensionValue(params) {
   const { value } = params;
   if (typeof value === "string")
-    return `"${value}"`;
+    return encodePrismaString({ value });
   if (Array.isArray(value)) {
     return `[${value.map((entry) => formatExtensionValue({ value: entry })).join(", ")}]`;
   }
@@ -787,7 +811,11 @@ function formatExtensionValue(params) {
 }
 function formatModel(params) {
   const { model, plan } = params;
-  const lines = [`model ${model.__name} {`];
+  const lines = [
+    ...model.__comment === undefined ? [] : model.__comment.split(`
+`).map((line) => `/// ${line}`),
+    `model ${model.__name} {`
+  ];
   lines.push("  //> Columns");
   for (const [name, column] of model.__columns) {
     lines.push(formatColumn({ name, column }));
@@ -804,7 +832,7 @@ function formatModel(params) {
     lines.push(formatIndex({ index }));
   }
   for (const check of model.__checks ?? []) {
-    lines.push(`  @@check(${JSON.stringify(check.expression)}, name: ${JSON.stringify(check.name)})`);
+    lines.push(`  @@check(${encodePrismaString({ value: check.expression })}, name: ${encodePrismaString({ value: check.name })})`);
   }
   for (const use of model.__extensions ?? []) {
     const args = [];
@@ -818,8 +846,13 @@ function formatModel(params) {
   if (model.__primaryKey !== undefined && model.__primaryKey.length > 0) {
     lines.push(`  @@id([${model.__primaryKey.join(", ")}])`);
   }
+  if (model.__policy !== undefined) {
+    const { field, context } = model.__policy;
+    const contextArg = context === undefined || context === field ? "" : `, context: ${encodePrismaString({ value: context })}`;
+    lines.push(`  @@policy([${field}]${contextArg})`);
+  }
   if (typeof model.__map === "string") {
-    lines.push(`  @@map("${model.__map}")`);
+    lines.push(`  @@map(${encodePrismaString({ value: model.__map })})`);
   }
   lines.push("}");
   return lines.join(`
@@ -831,6 +864,21 @@ function formatEnum(params) {
 `);
 }
 function generatePrisma(schema, _config = {}) {
+  const stringEnums = [...schema.__enumStorage].filter(([, storage]) => storage === "string").map(([name]) => name);
+  if (stringEnums.length > 0) {
+    throw new VibeError({
+      code: "VIBE_CONFIG",
+      message: `Cannot print to Prisma: enum(s) ${stringEnums.join(", ")} use storage: "string", which .prisma cannot express losslessly. Keep the DSL as the source or switch the enum to database storage.`,
+      meta: { enums: stringEnums, target: "prisma" }
+    });
+  }
+  if (schema.__rls !== undefined) {
+    throw new VibeError({
+      code: "VIBE_CONFIG",
+      message: "Cannot print to Prisma: this schema uses native RLS, which .prisma cannot express losslessly. Keep the DSL as the source.",
+      meta: { feature: "nativeRowLevelSecurity", target: "prisma" }
+    });
+  }
   const plan = planSchema({ schema });
   const sections = [];
   if (schema.__enums.size > 0) {
@@ -964,6 +1012,41 @@ function mergeRelations(...parts) {
 }
 
 // packages/dsl/src/schema.ts
+import { VibeError as VibeError2, validateRlsContextIR } from "@vibeorm/schema";
+function sameValues(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function registerEnum(params) {
+  const { registry, name, entry, origin } = params;
+  const existing = registry.get(name);
+  if (existing === undefined) {
+    registry.set(name, entry);
+    return;
+  }
+  const valuesDiffer = !sameValues(existing.values, entry.values);
+  const storageDiffers = existing.storage !== entry.storage;
+  if (!valuesDiffer && !storageDiffers)
+    return;
+  const detail = [
+    ...valuesDiffer ? [`values [${existing.values.join(", ")}] vs [${entry.values.join(", ")}]`] : [],
+    ...storageDiffers ? [`storage "${existing.storage}" vs "${entry.storage}"`] : []
+  ].join("; ");
+  throw new VibeError2({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `Enum "${name}" is defined more than once with conflicting definitions (${origin}): ${detail} \u2014 share one enum object across modules, or give the definitions different names`,
+    meta: {
+      issues: [
+        {
+          rule: "enum-conflict",
+          message: `Enum "${name}" reused with conflicting ${valuesDiffer ? "values" : "storage"} (${origin})`
+        }
+      ],
+      enum: name,
+      existing,
+      incoming: entry
+    }
+  });
+}
 function isModelDef(value) {
   return typeof value === "object" && value !== null && "__type" in value && value.__type === "model";
 }
@@ -971,53 +1054,137 @@ function isEnumDef(value) {
   return typeof value === "object" && value !== null && "__type" in value && value.__type === "enum";
 }
 function addModelTree(params) {
-  const { model, models } = params;
+  const { model, models, origin } = params;
+  const existing = models.get(model.__name);
+  if (existing !== undefined && existing !== model) {
+    throw new VibeError2({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Model "${model.__name}" is defined more than once with different definitions (${origin}) \u2014 ` + `share one model object across modules, or give the definitions different names`,
+      meta: {
+        issues: [
+          {
+            rule: "model-conflict",
+            message: `Model "${model.__name}" reused with a different definition (${origin})`,
+            model: model.__name
+          }
+        ],
+        model: model.__name
+      }
+    });
+  }
   models.set(model.__name, model);
   for (const childModel of model.__children.values()) {
-    addModelTree({ model: childModel, models });
+    addModelTree({ model: childModel, models, origin: `inline child of ${model.__name}` });
   }
 }
 function extractModelsAndEnums(params) {
-  const { input, models, standaloneEnums } = params;
+  const { input, models, enums } = params;
   for (const value of Object.values(input)) {
     if (isModelDef(value)) {
-      addModelTree({ model: value, models });
+      addModelTree({ model: value, models, origin: "listed in dsl.schema()" });
     } else if (isEnumDef(value)) {
-      standaloneEnums.set(value.__name, value.__options);
+      registerEnum({
+        registry: enums,
+        name: value.__name,
+        entry: { values: value.__options, storage: value.__storage },
+        origin: "standalone enum listed in dsl.schema()"
+      });
     } else if (typeof value === "object" && value !== null) {
-      extractModelsAndEnums({ input: value, models, standaloneEnums });
+      extractModelsAndEnums({ input: value, models, enums });
     }
   }
 }
 function resolveEnums(params) {
-  const { models, standaloneEnums } = params;
-  const enums = new Map(standaloneEnums);
+  const { models, enums } = params;
   for (const [modelName, model] of models) {
     for (const [columnName, column] of model.__columns) {
       if (column.__columnType !== "enum" || column.__enumValues === undefined)
         continue;
+      const entry = {
+        values: column.__enumValues,
+        storage: column.__enumStorage ?? "database"
+      };
       if (column.__enumName !== undefined) {
-        if (!enums.has(column.__enumName)) {
-          enums.set(column.__enumName, column.__enumValues);
-        }
+        registerEnum({
+          registry: enums,
+          name: column.__enumName,
+          entry,
+          origin: `standalone enum used by ${modelName}.${columnName}`
+        });
         continue;
       }
       const name = inlineEnumName({ modelName, columnName });
-      enums.set(name, column.__enumValues);
+      registerEnum({
+        registry: enums,
+        name,
+        entry,
+        origin: `inline enum on ${modelName}.${columnName}, named ${name}`
+      });
       column.__enumName = name;
     }
   }
-  return enums;
+}
+var RLS_CONTEXT_TYPES = {
+  string: "String",
+  boolean: "Boolean",
+  int: "Int",
+  bigint: "BigInt",
+  float: "Float",
+  decimal: "Decimal",
+  datetime: "DateTime"
+};
+function defineRls(params) {
+  if (typeof params.context !== "object" || params.context === null || Array.isArray(params.context)) {
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "RLS context must be a record of scalar declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+  }
+  const entries = [];
+  const refs = [];
+  for (const key of Reflect.ownKeys(params.context)) {
+    const descriptor = Object.getOwnPropertyDescriptor(params.context, key);
+    const column = descriptor?.value;
+    if (typeof key !== "string" || descriptor?.enumerable !== true || typeof column !== "object" || column === null || !("__columnType" in column) || !("__config" in column) || typeof column.__config !== "object" || column.__config === null || typeof column.__columnType !== "string" || !Object.hasOwn(RLS_CONTEXT_TYPES, column.__columnType) || "array" in column.__config && column.__config.array === true) {
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "RLS context slots must be named scalar column declarations", meta: { issues: [{ rule: "rls-invalid-context" }] } });
+    }
+    entries.push([key, { type: RLS_CONTEXT_TYPES[column.__columnType], nullable: "optional" in column.__config && column.__config.optional === true }]);
+    refs.push([key, Object.freeze({ context: key })]);
+  }
+  const context = Object.freeze(Object.fromEntries(entries));
+  const issues = validateRlsContextIR({ context });
+  if (issues.length > 0) {
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "Invalid RLS context declaration", meta: { issues } });
+  }
+  const policies = params.policies({ context: Object.freeze(Object.fromEntries(refs)) });
+  if (typeof policies !== "object" || policies === null || Array.isArray(policies)) {
+    throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be a record of model classifications", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+  }
+  const named = [];
+  const classified = new Set;
+  for (const key of Reflect.ownKeys(policies)) {
+    const descriptor = Object.getOwnPropertyDescriptor(policies, key);
+    if (typeof key !== "string" || descriptor?.enumerable !== true || !("value" in descriptor)) {
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: "RLS policies must be named data properties", meta: { issues: [{ rule: "rls-invalid-rule" }] } });
+    }
+    const name = params.models[key]?.__name ?? key;
+    if (classified.has(name)) {
+      throw new VibeError2({ code: "VIBE_SCHEMA_INVALID", message: `RLS classifies model "${name}" more than once`, meta: { issues: [{ rule: "rls-duplicate-classification", model: name }] } });
+    }
+    classified.add(name);
+    named.push([name, descriptor.value]);
+  }
+  return { context, policies: Object.fromEntries(named) };
 }
 function schema(input, options) {
   const models = new Map;
-  const standaloneEnums = new Map;
-  extractModelsAndEnums({ input, models, standaloneEnums });
+  const enums = new Map;
+  extractModelsAndEnums({ input, models, enums });
+  resolveEnums({ models, enums });
   return {
     __type: "schema",
     __models: models,
-    __enums: resolveEnums({ models, standaloneEnums }),
-    __relations: options?.relations ?? {}
+    __enums: new Map(Array.from(enums, ([name, entry]) => [name, entry.values])),
+    __enumStorage: new Map(Array.from(enums, ([name, entry]) => [name, entry.storage])),
+    __relations: options?.relations ?? {},
+    ...options?.rls === undefined ? {} : { __rls: options.rls }
   };
 }
 function domain(params) {
@@ -1131,8 +1298,9 @@ var templates = {
 // packages/dsl/src/to-ir.ts
 import {
   EMPTY_EXTENSION_REGISTRY,
-  VibeError,
+  VibeError as VibeError3,
   assertValidSchemaIR,
+  exactIntegerLiteral,
   mergeExtensionDeclarations
 } from "@vibeorm/schema";
 function fieldType(params) {
@@ -1198,12 +1366,25 @@ function fieldDefault(params) {
     return { kind: "literal", value };
   }
   if (typeof value === "bigint")
-    return { kind: "literal", value: Number(value) };
+    return { kind: "literal", value: exactIntegerLiteral({ text: value.toString() }) };
   return;
 }
 function nativeType(params) {
   const { column } = params;
-  if (column.__columnType === "string") {
+  if (column.__columnType === "enum") {
+    const { maxLength, text } = column.__config;
+    if (maxLength !== undefined || text !== undefined) {
+      const invalid = column.__enumStorage !== "string" || maxLength !== undefined && (typeof maxLength !== "number" || !Number.isSafeInteger(maxLength) || maxLength <= 0) || text !== undefined && typeof text !== "boolean" || text === true && maxLength !== undefined;
+      if (invalid) {
+        throw new VibeError3({
+          code: "VIBE_SCHEMA_INVALID",
+          message: "Enum text/maxLength options require string storage and either a positive integer maxLength or text: true, not both",
+          meta: { issues: [{ rule: "enum-string-storage-options", enum: column.__enumName }] }
+        });
+      }
+    }
+  }
+  if (column.__columnType === "string" || column.__columnType === "enum" && column.__enumStorage === "string") {
     const { maxLength, text } = column.__config;
     if (typeof maxLength === "number")
       return `VarChar(${maxLength})`;
@@ -1231,6 +1412,7 @@ function buildField(params) {
   const isList = column.__columnType !== "id" && config.array === true;
   const dbName = typeof config.map === "string" ? config.map : undefined;
   const documentation = typeof config.comment === "string" ? config.comment : undefined;
+  const collation = typeof config.collation === "string" ? config.collation : undefined;
   const defaultValue = fieldDefault({ column });
   const native = extensionNativeType ?? nativeType({ column });
   return {
@@ -1241,6 +1423,7 @@ function buildField(params) {
     isId: column.__columnType === "id",
     isUnique: config.unique === true,
     isUpdatedAt: column.__columnType === "datetime" && config.updatedAt === true,
+    ...collation === undefined ? {} : { collation },
     ...dbName === undefined ? {} : { dbName },
     ...defaultValue === undefined ? {} : { default: defaultValue },
     ...native === undefined ? {} : { nativeType: native },
@@ -1286,6 +1469,7 @@ function buildIndex(params) {
 function buildModel(params) {
   const { model, plan, extensions, declarations, issues } = params;
   const primaryKey = model.__primaryKey !== undefined && model.__primaryKey.length > 0 ? { fields: [...model.__primaryKey] } : undefined;
+  const policy = model.__policy === undefined ? undefined : { field: model.__policy.field, context: model.__policy.context ?? model.__policy.field };
   const fields2 = [];
   for (const [name, column] of model.__columns) {
     const extensionTypeName = column.__config["extensionType"];
@@ -1366,8 +1550,10 @@ function buildModel(params) {
     relations: (plan.relations.get(model.__name) ?? []).map((relation) => buildRelation({ relation, plan })),
     indexes: (plan.indexes.get(model.__name) ?? []).map((index) => buildIndex({ index })),
     ...model.__checks === undefined || model.__checks.length === 0 ? {} : { checks: model.__checks.map((check) => ({ name: check.name, expression: check.expression })) },
+    ...policy === undefined ? {} : { policy },
     ...primaryKey === undefined ? {} : { primaryKey },
-    isView: false
+    isView: false,
+    ...model.__comment === undefined ? {} : { documentation: model.__comment }
   };
 }
 
@@ -1394,13 +1580,25 @@ function toIR(params) {
   const plan = planSchema({ schema: schema2 });
   const declarations = new ExtensionDeclarationCollector;
   const issues = [];
-  const models = Array.from(schema2.__models.values(), (model) => buildModel({ model, plan, extensions, declarations, issues }));
+  const models = Array.from(schema2.__models.values(), (model) => {
+    const built = buildModel({ model, plan, extensions, declarations, issues });
+    const rls = schema2.__rls?.policies[model.__name];
+    return rls === undefined ? built : { ...built, rls };
+  });
+  if (schema2.__rls !== undefined) {
+    for (const name of Object.keys(schema2.__rls.policies)) {
+      if (!schema2.__models.has(name)) {
+        issues.push({ rule: "rls-unknown-model", model: name, message: `RLS classification references model "${name}" absent from the composed schema` });
+      }
+    }
+  }
   const enums = Array.from(schema2.__enums, ([name, values]) => ({
     name,
-    values: [...values]
+    values: [...values],
+    ...schema2.__enumStorage.get(name) === "string" ? { storage: "string" } : {}
   }));
   if (issues.length > 0) {
-    throw new VibeError({
+    throw new VibeError3({
       code: "VIBE_SCHEMA_INVALID",
       message: `Schema validation failed with ${issues.length} issue(s): ${issues.map((issue) => issue.message).join("; ")}`,
       meta: { issues }
@@ -1410,7 +1608,8 @@ function toIR(params) {
     datasource: { provider },
     models,
     enums,
-    extensions: declarations.toIR()
+    extensions: declarations.toIR(),
+    ...schema2.__rls === undefined ? {} : { rls: { context: schema2.__rls.context } }
   };
   assertValidSchemaIR({ schema: ir });
   return ir;
@@ -1534,6 +1733,7 @@ var dsl = {
   defineRelations,
   defineRelationsPart,
   mergeRelations,
+  defineRls,
   schema,
   domain,
   toIR,
@@ -1561,6 +1761,7 @@ export {
   dsl,
   domain,
   detectOneToOnePairs,
+  defineRls,
   defineRelationsPart,
   defineRelations,
   createIndexBuilder,
@@ -1579,4 +1780,4 @@ export {
   ChainableColumn
 };
 
-//# debugId=EB3F790CB1F4BD1C64756E2164756E21
+//# debugId=EC151CEC887B44C364756E2164756E21