@farming-labs/orm 0.0.1 → 0.0.3

package/dist/index.js

@@ -4,17 +4,38 @@ function createModelClient(schema, driver, model2) {
     findMany(args) {
       return driver.findMany(schema, model2, args ?? {});
     },
+    findOne(args) {
+      return driver.findFirst(schema, model2, args ?? {});
+    },
     findFirst(args) {
       return driver.findFirst(schema, model2, args ?? {});
     },
+    findUnique(args) {
+      return driver.findUnique(schema, model2, args);
+    },
+    count(args) {
+      return driver.count(schema, model2, args);
+    },
     create(args) {
       return driver.create(schema, model2, args);
     },
+    createMany(args) {
+      return driver.createMany(schema, model2, args);
+    },
     update(args) {
       return driver.update(schema, model2, args);
     },
+    updateMany(args) {
+      return driver.updateMany(schema, model2, args);
+    },
+    upsert(args) {
+      return driver.upsert(schema, model2, args);
+    },
     delete(args) {
       return driver.delete(schema, model2, args);
+    },
+    deleteMany(args) {
+      return driver.deleteMany(schema, model2, args);
     }
   };
 }
@@ -32,6 +53,13 @@ function createOrm(options) {
     });
     return run(tx);
   });
+  orm.batch = async (tasks) => orm.transaction(async (tx) => {
+    const results = [];
+    for (const task of tasks) {
+      results.push(await task(tx));
+    }
+    return results;
+  });
   return orm;
 }
 
@@ -155,6 +183,29 @@ 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`;
+function resolveReferenceTarget(manifest, model2, foreignKey, fallbackTarget) {
+  const reference = model2.fields[foreignKey]?.references;
+  if (!reference) {
+    return {
+      targetModel: fallbackTarget,
+      targetField: "id"
+    };
+  }
+  const [targetModel, targetField = "id"] = reference.split(".");
+  return {
+    targetModel,
+    targetField
+  };
+}
+function hasExplicitInverseRelation(manifest, modelName, sourceModel, foreignKey) {
+  const model2 = manifest.models[modelName];
+  if (!model2) return false;
+  return Object.values(model2.relations).some((relation) => {
+    if (relation.target !== sourceModel) return false;
+    if (relation.kind === "belongsTo" || relation.kind === "manyToMany") return false;
+    return relation.foreignKey === foreignKey;
+  });
+}
 function prismaType(field) {
   switch (field.kind) {
     case "id":
@@ -226,7 +277,7 @@ function sqlType(field, dialect) {
     return dialect === "mysql" ? "varchar(191)" : "text";
   }
   if (field.kind === "string") {
-    return dialect === "mysql" && field.unique ? "varchar(191)" : "text";
+    return dialect === "mysql" && (field.unique || field.references) ? "varchar(191)" : "text";
   }
   if (field.kind === "boolean") {
     return dialect === "sqlite" ? "integer" : "boolean";
@@ -239,6 +290,12 @@ function sqlType(field, dialect) {
   }
   return "timestamp";
 }
+function sqlIdentifier(dialect, value) {
+  if (dialect === "mysql") {
+    return `\`${value}\``;
+  }
+  return `"${value}"`;
+}
 function renderPrismaSchema(schema, options = {}) {
   const manifest = createManifest(schema);
   const provider = options.provider ?? "postgresql";
@@ -253,6 +310,7 @@ function renderPrismaSchema(schema, options = {}) {
         ...reverseRelations.get(targetModel) ?? [],
         {
           sourceModel: model2.name,
+          foreignKey: field.name,
           many: !field.unique
         }
       ]);
@@ -261,6 +319,8 @@ function renderPrismaSchema(schema, options = {}) {
   const blocks = Object.values(manifest.models).map((model2) => {
     const lines = [];
     const modelName = capitalize(model2.name);
+    const relationFieldNames = /* @__PURE__ */ new Set();
+    const handledForeignKeys = /* @__PURE__ */ new Set();
     for (const field of Object.values(model2.fields)) {
       const fieldType = prismaType(field);
       const modifiers = [];
@@ -277,16 +337,45 @@ function renderPrismaSchema(schema, options = {}) {
       lines.push(
         `  ${field.name} ${fieldType}${field.nullable ? "?" : ""}${modifiers.length ? ` ${modifiers.join(" ")}` : ""}`
       );
-      if (field.references) {
-        const [targetModel, targetField] = field.references.split(".");
+    }
+    for (const [relationName, relation] of Object.entries(model2.relations)) {
+      if (relation.kind === "manyToMany") continue;
+      relationFieldNames.add(relationName);
+      if (relation.kind === "belongsTo") {
+        const { targetField } = resolveReferenceTarget(
+          manifest,
+          model2,
+          relation.foreignKey,
+          relation.target
+        );
+        handledForeignKeys.add(relation.foreignKey);
         lines.push(
-          `  ${targetModel} ${capitalize(targetModel)} @relation(fields: [${field.name}], references: [${targetField}])`
+          `  ${relationName} ${capitalize(relation.target)} @relation(fields: [${relation.foreignKey}], references: [${targetField}])`
         );
+        continue;
+      }
+      if (relation.kind === "hasOne") {
+        lines.push(`  ${relationName} ${capitalize(relation.target)}?`);
+        continue;
       }
+      lines.push(`  ${relationName} ${capitalize(relation.target)}[]`);
+    }
+    for (const field of Object.values(model2.fields)) {
+      if (!field.references || handledForeignKeys.has(field.name)) continue;
+      const [targetModel, targetField] = field.references.split(".");
+      if (relationFieldNames.has(targetModel)) continue;
+      lines.push(
+        `  ${targetModel} ${capitalize(targetModel)} @relation(fields: [${field.name}], references: [${targetField}])`
+      );
     }
     for (const relation of reverseRelations.get(model2.name) ?? []) {
+      if (hasExplicitInverseRelation(manifest, model2.name, relation.sourceModel, relation.foreignKey)) {
+        continue;
+      }
+      const relationName = relation.many ? pluralize(relation.sourceModel) : relation.sourceModel;
+      if (relationFieldNames.has(relationName)) continue;
       lines.push(
-        relation.many ? `  ${pluralize(relation.sourceModel)} ${capitalize(relation.sourceModel)}[]` : `  ${relation.sourceModel} ${capitalize(relation.sourceModel)}?`
+        relation.many ? `  ${relationName} ${capitalize(relation.sourceModel)}[]` : `  ${relationName} ${capitalize(relation.sourceModel)}?`
       );
     }
     const mapLine = model2.table !== modelName ? `
@@ -309,7 +398,7 @@ ${blocks.join("\n\n")}
 }
 function renderDrizzleSchema(schema, options) {
   const manifest = createManifest(schema);
-  const imports = drizzleImports(options.dialect, manifest).join(", ");
+  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 lines = Object.values(model2.fields).map((field) => {
@@ -324,16 +413,48 @@ function renderDrizzleSchema(schema, options) {
 ${lines.join(",\n")}
 });`;
   });
-  return `import { ${imports} } from "drizzle-orm/${options.dialect === "pg" ? "pg-core" : options.dialect === "mysql" ? "mysql-core" : "sqlite-core"}";
+  const relationBlocks = Object.values(manifest.models).map((model2) => {
+    const lines = Object.entries(model2.relations).flatMap(([relationName, relation]) => {
+      if (relation.kind === "manyToMany") {
+        return [];
+      }
+      if (relation.kind === "belongsTo") {
+        const { targetField } = resolveReferenceTarget(
+          manifest,
+          model2,
+          relation.foreignKey,
+          relation.target
+        );
+        return [
+          `  ${relationName}: one(${relation.target}, { fields: [${model2.name}.${relation.foreignKey}], references: [${relation.target}.${targetField}] })`
+        ];
+      }
+      if (relation.kind === "hasOne") {
+        return [`  ${relationName}: one(${relation.target})`];
+      }
+      return [`  ${relationName}: many(${relation.target})`];
+    }).filter(Boolean);
+    if (!lines.length) return null;
+    return `export const ${model2.name}Relations = relations(${model2.name}, ({ one, many }) => ({
+${lines.join(",\n")}
+}));`;
+  }).filter(Boolean);
+  const imports = [
+    `import { ${coreImports} } from "drizzle-orm/${options.dialect === "pg" ? "pg-core" : options.dialect === "mysql" ? "mysql-core" : "sqlite-core"}";`,
+    relationBlocks.length ? `import { relations } from "drizzle-orm";` : null
+  ].filter(Boolean).join("\n");
+  return `${imports}
 
-${modelBlocks.join("\n\n")}
+${[...modelBlocks, ...relationBlocks].join("\n\n")}
 `;
 }
 function renderSafeSql(schema, options) {
   const manifest = createManifest(schema);
   const statements = Object.values(manifest.models).map((model2) => {
     const columns = Object.values(model2.fields).map((field) => {
-      const parts = [`${field.column} ${sqlType(field, options.dialect)}`];
+      const parts = [
+        `${sqlIdentifier(options.dialect, field.column)} ${sqlType(field, options.dialect)}`
+      ];
       if (field.kind === "id") parts.push("primary key");
       if (!field.nullable) parts.push("not null");
       if (field.unique && field.kind !== "id") parts.push("unique");
@@ -345,11 +466,17 @@ function renderSafeSql(schema, options) {
       if (field.references) {
         const [targetModel, targetField] = field.references.split(".");
         const targetTable = manifest.models[targetModel]?.table ?? targetModel;
-        parts.push(`references ${targetTable}(${targetField})`);
+        const targetColumn = manifest.models[targetModel]?.fields[targetField]?.column ?? targetField;
+        parts.push(
+          `references ${sqlIdentifier(options.dialect, targetTable)}(${sqlIdentifier(
+            options.dialect,
+            targetColumn
+          )})`
+        );
       }
       return `  ${parts.join(" ")}`;
     });
-    return `create table if not exists ${model2.table} (
+    return `create table if not exists ${sqlIdentifier(options.dialect, model2.table)} (
 ${columns.join(",\n")}
 );`;
   });
@@ -466,6 +593,11 @@ function pageRows(rows, skip, take) {
   const end = take === void 0 ? void 0 : start + take;
   return rows.slice(start, end);
 }
+function applyQuery(rows, args = {}) {
+  const filtered = rows.filter((row) => matchesWhere(row, args.where));
+  const sorted = sortRows(filtered, args.orderBy);
+  return pageRows(sorted, args.skip, args.take);
+}
 function createMemoryDriver(seed) {
   const state = structuredClone(seed ?? {});
   function getRows(model2) {
@@ -473,14 +605,13 @@ function createMemoryDriver(seed) {
     state[model2] = rows;
     return rows;
   }
-  function applyQuery(model2, args) {
-    const rows = getRows(model2);
-    const filtered = rows.filter((row) => matchesWhere(row, args.where));
-    const sorted = sortRows(
-      filtered,
-      args.orderBy
-    );
-    return pageRows(sorted, args.skip, args.take);
+  function buildRow(schema, model2, data) {
+    const modelDefinition = schema.models[model2];
+    const nextRow = {};
+    for (const [fieldName, field] of Object.entries(modelDefinition.fields)) {
+      nextRow[fieldName] = applyDefault(data[fieldName], field.config);
+    }
+    return nextRow;
   }
   async function projectRow(schema, model2, row, select) {
     const modelDefinition = schema.models[model2];
@@ -513,28 +644,27 @@ function createMemoryDriver(seed) {
     const relation = schema.models[model2].relations[relationName];
     const relationArgs = value === true ? {} : value;
     if (relation.kind === "belongsTo") {
-      const targetRows2 = getRows(relation.target);
       const foreignValue = row[relation.foreignKey];
-      const target = targetRows2.find((item) => item.id === foreignValue);
+      const targetRows2 = getRows(relation.target).filter(
+        (item) => item.id === foreignValue
+      );
+      const target = applyQuery(targetRows2, relationArgs)[0];
       return target ? projectRow(schema, relation.target, target, relationArgs.select) : null;
     }
     if (relation.kind === "hasOne") {
-      const targetRows2 = getRows(relation.target);
-      const target = targetRows2.find((item) => item[relation.foreignKey] === row.id);
+      const targetRows2 = getRows(relation.target).filter(
+        (item) => item[relation.foreignKey] === row.id
+      );
+      const target = applyQuery(targetRows2, relationArgs)[0];
       return target ? projectRow(schema, relation.target, target, relationArgs.select) : null;
     }
     if (relation.kind === "hasMany") {
       const targetRows2 = getRows(relation.target).filter(
         (item) => item[relation.foreignKey] === row.id
       );
-      const sorted2 = sortRows(
-        targetRows2,
-        relationArgs.orderBy
-      );
-      const paged2 = pageRows(sorted2, relationArgs.skip, relationArgs.take);
-      const filtered2 = paged2.filter((item) => matchesWhere(item, relationArgs.where));
+      const matchedRows2 = applyQuery(targetRows2, relationArgs);
       return Promise.all(
-        filtered2.map(
+        matchedRows2.map(
           (item) => projectRow(schema, relation.target, item, relationArgs.select)
         )
       );
@@ -546,45 +676,72 @@ function createMemoryDriver(seed) {
     const targetRows = getRows(relation.target).filter(
       (item) => targetIds.includes(item.id)
     );
-    const sorted = sortRows(
-      targetRows,
-      relationArgs.orderBy
-    );
-    const paged = pageRows(sorted, relationArgs.skip, relationArgs.take);
-    const filtered = paged.filter((item) => matchesWhere(item, relationArgs.where));
+    const matchedRows = applyQuery(targetRows, relationArgs);
     return Promise.all(
-      filtered.map(
+      matchedRows.map(
         (item) => projectRow(schema, relation.target, item, relationArgs.select)
       )
     );
   }
   const driver = {
     async findMany(schema, model2, args) {
-      const rows = applyQuery(model2, args);
+      const rows = applyQuery(getRows(model2), args);
       return Promise.all(rows.map((row) => projectRow(schema, model2, row, args.select)));
     },
     async findFirst(schema, model2, args) {
-      const row = applyQuery(model2, args)[0];
+      const row = applyQuery(getRows(model2), args)[0];
+      if (!row) return null;
+      return projectRow(schema, model2, row, args.select);
+    },
+    async findUnique(schema, model2, args) {
+      const row = applyQuery(getRows(model2), args)[0];
       if (!row) return null;
       return projectRow(schema, model2, row, args.select);
     },
+    async count(_schema, model2, args) {
+      return applyQuery(getRows(model2), args).length;
+    },
     async create(schema, model2, args) {
-      const modelDefinition = schema.models[model2];
-      const nextRow = {};
-      for (const [fieldName, field] of Object.entries(modelDefinition.fields)) {
-        nextRow[fieldName] = applyDefault(args.data[fieldName], field.config);
-      }
+      const nextRow = buildRow(schema, model2, args.data);
       getRows(model2).push(nextRow);
       return projectRow(schema, model2, nextRow, args.select);
     },
+    async createMany(schema, model2, args) {
+      const rows = args.data.map((entry) => buildRow(schema, model2, entry));
+      getRows(model2).push(...rows);
+      return Promise.all(rows.map((row) => projectRow(schema, model2, row, args.select)));
+    },
     async update(schema, model2, args) {
-      const rows = getRows(model2);
-      const row = rows.find((item) => matchesWhere(item, args.where));
+      const row = getRows(model2).find((item) => matchesWhere(item, args.where));
       if (!row) return null;
       Object.assign(row, args.data);
       return projectRow(schema, model2, row, args.select);
     },
+    async updateMany(_schema, model2, args) {
+      const rows = getRows(model2).filter((item) => matchesWhere(item, args.where));
+      for (const row of rows) {
+        Object.assign(row, args.data);
+      }
+      return rows.length;
+    },
+    async upsert(schema, model2, args) {
+      const row = getRows(model2).find((item) => matchesWhere(item, args.where));
+      if (row) {
+        Object.assign(row, args.update);
+        return projectRow(schema, model2, row, args.select);
+      }
+      const created = buildRow(schema, model2, args.create);
+      getRows(model2).push(created);
+      return projectRow(schema, model2, created, args.select);
+    },
     async delete(_schema, model2, args) {
+      const rows = getRows(model2);
+      const index = rows.findIndex((item) => matchesWhere(item, args.where));
+      if (index === -1) return 0;
+      rows.splice(index, 1);
+      return 1;
+    },
+    async deleteMany(_schema, model2, args) {
       const rows = getRows(model2);
       const before = rows.length;
       state[model2] = rows.filter((item) => !matchesWhere(item, args.where));