@farming-labs/orm 0.0.8 → 0.0.9

package/dist/index.cjs

@@ -187,6 +187,38 @@ function datetime() {
 }
 
 // src/manifest.ts
+function createConstraintName(table, columns, suffix) {
+  const base = [table, ...columns].join("_").replace(/[^a-zA-Z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+  return `${base}_${suffix}`;
+}
+function normalizeConstraints(modelName, table, fields, constraints) {
+  const normalize = (entries, unique) => (entries ?? []).map((entry) => {
+    if (!entry.length) {
+      throw new Error(
+        `Model "${modelName}" defines an empty ${unique ? "unique" : "index"} constraint.`
+      );
+    }
+    const columns = entry.map((fieldName) => {
+      const field = fields[fieldName];
+      if (!field) {
+        throw new Error(
+          `Model "${modelName}" defines a ${unique ? "unique" : "index"} constraint on unknown field "${fieldName}".`
+        );
+      }
+      return field.column;
+    });
+    return {
+      name: createConstraintName(table, columns, unique ? "unique" : "idx"),
+      fields: [...entry],
+      columns,
+      unique
+    };
+  });
+  return {
+    unique: normalize(constraints.unique, true),
+    indexes: normalize(constraints.indexes, false)
+  };
+}
 function createManifest(schema) {
   const models = Object.fromEntries(
     Object.entries(schema.models).map(
@@ -214,7 +246,13 @@ function createManifest(schema) {
             table: definition.table,
             description: definition.description,
             fields,
-            relations: definition.relations
+            relations: definition.relations,
+            constraints: normalizeConstraints(
+              name,
+              definition.table,
+              fields,
+              definition.constraints
+            )
           }
         ];
       }
@@ -226,6 +264,7 @@ function createManifest(schema) {
 // src/generators.ts
 var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
 var pluralize = (value) => value.endsWith("s") ? value : `${value}s`;
+var camelize = (value) => value.replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()).replace(/^[^a-zA-Z]+/, "").replace(/^[A-Z]/, (char) => char.toLowerCase());
 function resolveReferenceTarget(manifest, model2, foreignKey, fallbackTarget) {
   const reference = model2.fields[foreignKey]?.references;
   if (!reference) {
@@ -260,6 +299,16 @@ function prismaType(field) {
       return "DateTime";
   }
 }
+function drizzleConstraintProperty(constraint) {
+  return camelize(constraint.name) || "constraint";
+}
+function constrainedFields(model2) {
+  return new Set(
+    [...model2.constraints.unique, ...model2.constraints.indexes].flatMap(
+      (constraint) => constraint.fields
+    )
+  );
+}
 function drizzleImports(dialect, manifest) {
   const models = Object.values(manifest.models);
   const needsBoolean = models.some(
@@ -268,12 +317,17 @@ function drizzleImports(dialect, manifest) {
   const needsDate = models.some(
     (model2) => Object.values(model2.fields).some((field) => field.kind === "datetime")
   );
+  const needsIndexes = models.some(
+    (model2) => model2.constraints.indexes.length || model2.constraints.unique.length
+  );
   if (dialect === "pg") {
     return [
       "pgTable",
       "text",
       needsBoolean ? "boolean" : null,
-      needsDate ? "timestamp" : null
+      needsDate ? "timestamp" : null,
+      needsIndexes ? "index" : null,
+      needsIndexes ? "uniqueIndex" : null
     ].filter(Boolean);
   }
   if (dialect === "mysql") {
@@ -282,12 +336,20 @@ function drizzleImports(dialect, manifest) {
       "varchar",
       "text",
       needsBoolean ? "boolean" : null,
-      needsDate ? "datetime" : null
+      needsDate ? "datetime" : null,
+      needsIndexes ? "index" : null,
+      needsIndexes ? "uniqueIndex" : null
     ].filter(Boolean);
   }
-  return ["sqliteTable", "text", "integer"];
+  return [
+    "sqliteTable",
+    "text",
+    "integer",
+    needsIndexes ? "index" : null,
+    needsIndexes ? "uniqueIndex" : null
+  ].filter(Boolean);
 }
-function drizzleColumn(field, dialect) {
+function drizzleColumn(field, dialect, options = {}) {
   if (field.kind === "id") {
     if (dialect === "mysql") {
       return `varchar("${field.column}", { length: 191 }).primaryKey()`;
@@ -296,7 +358,7 @@ function drizzleColumn(field, dialect) {
   }
   if (field.kind === "string") {
     if (dialect === "mysql") {
-      const base = field.unique || field.references ? `varchar("${field.column}", { length: 191 })` : `text("${field.column}")`;
+      const base = field.unique || field.references || options.indexed ? `varchar("${field.column}", { length: 191 })` : `text("${field.column}")`;
       return `${base}${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${field.defaultValue !== void 0 ? `.default(${JSON.stringify(field.defaultValue)})` : ""}`;
     }
     return `text("${field.column}")${field.nullable ? "" : ".notNull()"}${field.unique ? ".unique()" : ""}${field.defaultValue !== void 0 ? `.default(${JSON.stringify(field.defaultValue)})` : ""}`;
@@ -313,14 +375,14 @@ function drizzleColumn(field, dialect) {
   if (dialect === "sqlite") {
     return `integer("${field.column}", { mode: "timestamp" })${field.nullable ? "" : ".notNull()"}`;
   }
-  return `timestamp("${field.column}")${field.nullable ? "" : ".notNull()"}`;
+  return `timestamp("${field.column}", { withTimezone: true, mode: "date" })${field.nullable ? "" : ".notNull()"}`;
 }
-function sqlType(field, dialect) {
+function sqlType(field, dialect, options = {}) {
   if (field.kind === "id") {
     return dialect === "mysql" ? "varchar(191)" : "text";
   }
   if (field.kind === "string") {
-    return dialect === "mysql" && (field.unique || field.references) ? "varchar(191)" : "text";
+    return dialect === "mysql" && (field.unique || field.references || options.indexed) ? "varchar(191)" : "text";
   }
   if (field.kind === "boolean") {
     return dialect === "sqlite" ? "integer" : "boolean";
@@ -331,7 +393,7 @@ function sqlType(field, dialect) {
   if (dialect === "sqlite") {
     return "text";
   }
-  return "timestamp";
+  return "timestamptz";
 }
 function sqlIdentifier(dialect, value) {
   if (dialect === "mysql") {
@@ -339,6 +401,14 @@ function sqlIdentifier(dialect, value) {
   }
   return `"${value}"`;
 }
+function sqlCreateIndexStatement(dialect, table, constraint) {
+  const indexName = sqlIdentifier(dialect, constraint.name);
+  const tableName = sqlIdentifier(dialect, table);
+  const columns = constraint.columns.map((column) => sqlIdentifier(dialect, column)).join(", ");
+  const createKeyword = constraint.unique ? "create unique index" : "create index";
+  const ifNotExists = dialect === "mysql" ? "" : " if not exists";
+  return `${createKeyword}${ifNotExists} ${indexName} on ${tableName}(${columns});`;
+}
 function renderPrismaSchema(schema, options = {}) {
   const manifest = createManifest(schema);
   const provider = options.provider ?? "postgresql";
@@ -421,10 +491,18 @@ function renderPrismaSchema(schema, options = {}) {
         relation.many ? `  ${relationName} ${capitalize(relation.sourceModel)}[]` : `  ${relationName} ${capitalize(relation.sourceModel)}?`
       );
     }
-    const mapLine = model2.table !== modelName ? `
-  @@map("${model2.table}")` : "";
+    const modelLines = [
+      ...lines,
+      ...model2.constraints.unique.map(
+        (constraint) => `  @@unique([${constraint.fields.join(", ")}])`
+      ),
+      ...model2.constraints.indexes.map(
+        (constraint) => `  @@index([${constraint.fields.join(", ")}])`
+      ),
+      ...model2.table !== modelName ? [`  @@map("${model2.table}")`] : []
+    ];
     return `model ${modelName} {
-${lines.join("\n")}${mapLine}
+${modelLines.join("\n")}
 }`;
   });
   return `generator ${generatorName} {
@@ -444,17 +522,33 @@ function renderDrizzleSchema(schema, options) {
   const coreImports = drizzleImports(options.dialect, manifest).join(", ");
   const tableFactory = options.dialect === "pg" ? "pgTable" : options.dialect === "mysql" ? "mysqlTable" : "sqliteTable";
   const modelBlocks = Object.values(manifest.models).map((model2) => {
+    const indexedFields = constrainedFields(model2);
     const lines = Object.values(model2.fields).map((field) => {
-      let value = drizzleColumn(field, options.dialect);
+      let value = drizzleColumn(field, options.dialect, { indexed: indexedFields.has(field.name) });
       if (field.references) {
         const [targetModel, targetField] = field.references.split(".");
         value += `.references(() => ${targetModel}.${targetField})`;
       }
       return `  ${field.name}: ${value}`;
     });
-    return `export const ${model2.name} = ${tableFactory}("${model2.table}", {
+    const constraintLines = [
+      ...model2.constraints.unique.map(
+        (constraint) => `  ${drizzleConstraintProperty(constraint)}: uniqueIndex("${constraint.name}").on(${constraint.fields.map((fieldName) => `table.${fieldName}`).join(", ")})`
+      ),
+      ...model2.constraints.indexes.map(
+        (constraint) => `  ${drizzleConstraintProperty(constraint)}: index("${constraint.name}").on(${constraint.fields.map((fieldName) => `table.${fieldName}`).join(", ")})`
+      )
+    ];
+    if (!constraintLines.length) {
+      return `export const ${model2.name} = ${tableFactory}("${model2.table}", {
 ${lines.join(",\n")}
 });`;
+    }
+    return `export const ${model2.name} = ${tableFactory}("${model2.table}", {
+${lines.join(",\n")}
+}, (table) => ({
+${constraintLines.join(",\n")}
+}));`;
   });
   const relationBlocks = Object.values(manifest.models).map((model2) => {
     const lines = Object.entries(model2.relations).flatMap(([relationName, relation]) => {
@@ -493,10 +587,13 @@ ${[...modelBlocks, ...relationBlocks].join("\n\n")}
 }
 function renderSafeSql(schema, options) {
   const manifest = createManifest(schema);
-  const statements = Object.values(manifest.models).map((model2) => {
+  const statements = Object.values(manifest.models).flatMap((model2) => {
+    const indexedFields = constrainedFields(model2);
     const columns = Object.values(model2.fields).map((field) => {
       const parts = [
-        `${sqlIdentifier(options.dialect, field.column)} ${sqlType(field, options.dialect)}`
+        `${sqlIdentifier(options.dialect, field.column)} ${sqlType(field, options.dialect, {
+          indexed: indexedFields.has(field.name)
+        })}`
       ];
       if (field.kind === "id") parts.push("primary key");
       if (!field.nullable) parts.push("not null");
@@ -519,9 +616,17 @@ function renderSafeSql(schema, options) {
       }
       return `  ${parts.join(" ")}`;
     });
-    return `create table if not exists ${sqlIdentifier(options.dialect, model2.table)} (
+    return [
+      `create table if not exists ${sqlIdentifier(options.dialect, model2.table)} (
 ${columns.join(",\n")}
-);`;
+);`,
+      ...model2.constraints.unique.map(
+        (constraint) => sqlCreateIndexStatement(options.dialect, model2.table, constraint)
+      ),
+      ...model2.constraints.indexes.map(
+        (constraint) => sqlCreateIndexStatement(options.dialect, model2.table, constraint)
+      )
+    ];
   });
   return `${statements.join("\n\n")}
 `;
@@ -845,6 +950,7 @@ function model(config) {
     table: config.table,
     fields: config.fields,
     relations: config.relations ?? {},
+    constraints: config.constraints ?? {},
     description: config.description
   };
 }