@farming-labs/orm 0.0.1

package/dist/index.js

@@ -0,0 +1,677 @@
+// src/client.ts
+function createModelClient(schema, driver, model2) {
+  return {
+    findMany(args) {
+      return driver.findMany(schema, model2, args ?? {});
+    },
+    findFirst(args) {
+      return driver.findFirst(schema, model2, args ?? {});
+    },
+    create(args) {
+      return driver.create(schema, model2, args);
+    },
+    update(args) {
+      return driver.update(schema, model2, args);
+    },
+    delete(args) {
+      return driver.delete(schema, model2, args);
+    }
+  };
+}
+function createOrm(options) {
+  const { schema, driver } = options;
+  const models = {};
+  for (const model2 of Object.keys(schema.models)) {
+    models[model2] = createModelClient(schema, driver, model2);
+  }
+  const orm = models;
+  orm.transaction = (run) => driver.transaction(schema, async (txDriver) => {
+    const tx = createOrm({
+      schema,
+      driver: txDriver
+    });
+    return run(tx);
+  });
+  return orm;
+}
+
+// src/fields.ts
+var cloneField = (config) => new FieldBuilder(config);
+var FieldBuilder = class {
+  constructor(config) {
+    this.config = config;
+  }
+  _tag = "field";
+  unique() {
+    return cloneField({
+      ...this.config,
+      unique: true
+    });
+  }
+  nullable() {
+    return cloneField({
+      ...this.config,
+      nullable: true
+    });
+  }
+  default(value) {
+    return cloneField({
+      ...this.config,
+      defaultValue: value
+    });
+  }
+  defaultNow() {
+    return cloneField({
+      ...this.config,
+      generated: "now"
+    });
+  }
+  references(reference) {
+    return cloneField({
+      ...this.config,
+      references: reference
+    });
+  }
+  map(name) {
+    return cloneField({
+      ...this.config,
+      mappedName: name
+    });
+  }
+  describe(description) {
+    return cloneField({
+      ...this.config,
+      description
+    });
+  }
+};
+function id() {
+  return new FieldBuilder({
+    kind: "id",
+    nullable: false,
+    unique: true,
+    generated: "id"
+  });
+}
+function string() {
+  return new FieldBuilder({
+    kind: "string",
+    nullable: false,
+    unique: false
+  });
+}
+function boolean() {
+  return new FieldBuilder({
+    kind: "boolean",
+    nullable: false,
+    unique: false
+  });
+}
+function datetime() {
+  return new FieldBuilder({
+    kind: "datetime",
+    nullable: false,
+    unique: false
+  });
+}
+
+// src/manifest.ts
+function createManifest(schema) {
+  const models = Object.fromEntries(
+    Object.entries(schema.models).map(
+      ([name, definition]) => {
+        const fields = Object.fromEntries(
+          Object.entries(definition.fields).map(([fieldName, field]) => [
+            fieldName,
+            {
+              name: fieldName,
+              column: field.config.mappedName ?? fieldName,
+              kind: field.config.kind,
+              nullable: field.config.nullable,
+              unique: field.config.unique,
+              generated: field.config.generated,
+              defaultValue: field.config.defaultValue,
+              references: field.config.references,
+              description: field.config.description
+            }
+          ])
+        );
+        return [
+          name,
+          {
+            name,
+            table: definition.table,
+            description: definition.description,
+            fields,
+            relations: definition.relations
+          }
+        ];
+      }
+    )
+  );
+  return { models };
+}
+
+// src/generators.ts
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+var pluralize = (value) => value.endsWith("s") ? value : `${value}s`;
+function prismaType(field) {
+  switch (field.kind) {
+    case "id":
+    case "string":
+      return "String";
+    case "boolean":
+      return "Boolean";
+    case "datetime":
+      return "DateTime";
+  }
+}
+function drizzleImports(dialect, manifest) {
+  const models = Object.values(manifest.models);
+  const needsBoolean = models.some(
+    (model2) => Object.values(model2.fields).some((field) => field.kind === "boolean")
+  );
+  const needsDate = models.some(
+    (model2) => Object.values(model2.fields).some((field) => field.kind === "datetime")
+  );
+  if (dialect === "pg") {
+    return [
+      "pgTable",
+      "text",
+      needsBoolean ? "boolean" : null,
+      needsDate ? "timestamp" : null
+    ].filter(Boolean);
+  }
+  if (dialect === "mysql") {
+    return [
+      "mysqlTable",
+      "varchar",
+      "text",
+      needsBoolean ? "boolean" : null,
+      needsDate ? "datetime" : null
+    ].filter(Boolean);
+  }
+  return ["sqliteTable", "text", "integer"];
+}
+function drizzleColumn(field, dialect) {
+  if (field.kind === "id") {
+    if (dialect === "mysql") {
+      return `varchar("${field.column}", { length: 191 }).primaryKey()`;
+    }
+    return `text("${field.column}").primaryKey()`;
+  }
+  if (field.kind === "string") {
+    if (dialect === "mysql") {
+      const base = field.unique || field.references ? `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)})` : ""}`;
+  }
+  if (field.kind === "boolean") {
+    if (dialect === "sqlite") {
+      return `integer("${field.column}", { mode: "boolean" })${field.nullable ? "" : ".notNull()"}${field.defaultValue !== void 0 ? `.default(${String(field.defaultValue)})` : ""}`;
+    }
+    return `boolean("${field.column}")${field.nullable ? "" : ".notNull()"}${field.defaultValue !== void 0 ? `.default(${String(field.defaultValue)})` : ""}`;
+  }
+  if (dialect === "mysql") {
+    return `datetime("${field.column}", { mode: "date" })${field.nullable ? "" : ".notNull()"}`;
+  }
+  if (dialect === "sqlite") {
+    return `integer("${field.column}", { mode: "timestamp" })${field.nullable ? "" : ".notNull()"}`;
+  }
+  return `timestamp("${field.column}")${field.nullable ? "" : ".notNull()"}`;
+}
+function sqlType(field, dialect) {
+  if (field.kind === "id") {
+    return dialect === "mysql" ? "varchar(191)" : "text";
+  }
+  if (field.kind === "string") {
+    return dialect === "mysql" && field.unique ? "varchar(191)" : "text";
+  }
+  if (field.kind === "boolean") {
+    return dialect === "sqlite" ? "integer" : "boolean";
+  }
+  if (dialect === "mysql") {
+    return "datetime";
+  }
+  if (dialect === "sqlite") {
+    return "text";
+  }
+  return "timestamp";
+}
+function renderPrismaSchema(schema, options = {}) {
+  const manifest = createManifest(schema);
+  const provider = options.provider ?? "postgresql";
+  const generatorName = options.generatorName ?? "client";
+  const datasourceName = options.datasourceName ?? "db";
+  const reverseRelations = /* @__PURE__ */ new Map();
+  for (const model2 of Object.values(manifest.models)) {
+    for (const field of Object.values(model2.fields)) {
+      if (!field.references) continue;
+      const [targetModel] = field.references.split(".");
+      reverseRelations.set(targetModel, [
+        ...reverseRelations.get(targetModel) ?? [],
+        {
+          sourceModel: model2.name,
+          many: !field.unique
+        }
+      ]);
+    }
+  }
+  const blocks = Object.values(manifest.models).map((model2) => {
+    const lines = [];
+    const modelName = capitalize(model2.name);
+    for (const field of Object.values(model2.fields)) {
+      const fieldType = prismaType(field);
+      const modifiers = [];
+      if (field.kind === "id") modifiers.push("@id");
+      if (field.generated === "id") modifiers.push("@default(cuid())");
+      if (field.generated === "now") modifiers.push("@default(now())");
+      if (field.defaultValue !== void 0 && field.generated === void 0) {
+        modifiers.push(
+          typeof field.defaultValue === "string" ? `@default("${field.defaultValue}")` : `@default(${String(field.defaultValue)})`
+        );
+      }
+      if (field.unique && field.kind !== "id") modifiers.push("@unique");
+      if (field.column !== field.name) modifiers.push(`@map("${field.column}")`);
+      lines.push(
+        `  ${field.name} ${fieldType}${field.nullable ? "?" : ""}${modifiers.length ? ` ${modifiers.join(" ")}` : ""}`
+      );
+      if (field.references) {
+        const [targetModel, targetField] = field.references.split(".");
+        lines.push(
+          `  ${targetModel} ${capitalize(targetModel)} @relation(fields: [${field.name}], references: [${targetField}])`
+        );
+      }
+    }
+    for (const relation of reverseRelations.get(model2.name) ?? []) {
+      lines.push(
+        relation.many ? `  ${pluralize(relation.sourceModel)} ${capitalize(relation.sourceModel)}[]` : `  ${relation.sourceModel} ${capitalize(relation.sourceModel)}?`
+      );
+    }
+    const mapLine = model2.table !== modelName ? `
+  @@map("${model2.table}")` : "";
+    return `model ${modelName} {
+${lines.join("\n")}${mapLine}
+}`;
+  });
+  return `generator ${generatorName} {
+  provider = "prisma-client-js"
+}
+
+datasource ${datasourceName} {
+  provider = "${provider}"
+  url      = ${provider === "sqlite" ? '"file:./dev.db"' : 'env("DATABASE_URL")'}
+}
+
+${blocks.join("\n\n")}
+`;
+}
+function renderDrizzleSchema(schema, options) {
+  const manifest = createManifest(schema);
+  const imports = 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) => {
+      let value = drizzleColumn(field, options.dialect);
+      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}", {
+${lines.join(",\n")}
+});`;
+  });
+  return `import { ${imports} } from "drizzle-orm/${options.dialect === "pg" ? "pg-core" : options.dialect === "mysql" ? "mysql-core" : "sqlite-core"}";
+
+${modelBlocks.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)}`];
+      if (field.kind === "id") parts.push("primary key");
+      if (!field.nullable) parts.push("not null");
+      if (field.unique && field.kind !== "id") parts.push("unique");
+      if (field.defaultValue !== void 0) {
+        parts.push(
+          `default ${typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : String(field.defaultValue)}`
+        );
+      }
+      if (field.references) {
+        const [targetModel, targetField] = field.references.split(".");
+        const targetTable = manifest.models[targetModel]?.table ?? targetModel;
+        parts.push(`references ${targetTable}(${targetField})`);
+      }
+      return `  ${parts.join(" ")}`;
+    });
+    return `create table if not exists ${model2.table} (
+${columns.join(",\n")}
+);`;
+  });
+  return `${statements.join("\n\n")}
+`;
+}
+function replaceGeneratedBlock(input) {
+  const start = `// @farming-labs/orm:start:${input.label}`;
+  const end = `// @farming-labs/orm:end:${input.label}`;
+  const block = `${start}
+${input.content.trim()}
+${end}`;
+  if (input.current.includes(start) && input.current.includes(end)) {
+    const pattern = new RegExp(`${start}[\\s\\S]*?${end}`, "m");
+    return input.current.replace(pattern, block);
+  }
+  return `${input.current.trim()}
+
+${block}
+`;
+}
+
+// src/memory.ts
+import { randomUUID } from "crypto";
+var isDate = (value) => value instanceof Date;
+function evaluateFilter(value, filter) {
+  if (filter === void 0 || filter === null || typeof filter !== "object" || isDate(filter) || Array.isArray(filter)) {
+    return value === filter;
+  }
+  const record = filter;
+  if ("eq" in record && value !== record.eq) return false;
+  if ("not" in record && value === record.not) return false;
+  if ("in" in record) {
+    const values = Array.isArray(record.in) ? record.in : [];
+    if (!values.includes(value)) return false;
+  }
+  if ("contains" in record) {
+    if (typeof value !== "string" || typeof record.contains !== "string") return false;
+    if (!value.includes(record.contains)) return false;
+  }
+  if ("gt" in record && value !== void 0) {
+    if (!(value instanceof Date || typeof value === "number" || typeof value === "string")) {
+      return false;
+    }
+    if (!(value > record.gt)) return false;
+  }
+  if ("gte" in record && value !== void 0) {
+    if (!(value instanceof Date || typeof value === "number" || typeof value === "string")) {
+      return false;
+    }
+    if (!(value >= record.gte)) return false;
+  }
+  if ("lt" in record && value !== void 0) {
+    if (!(value instanceof Date || typeof value === "number" || typeof value === "string")) {
+      return false;
+    }
+    if (!(value < record.lt)) return false;
+  }
+  if ("lte" in record && value !== void 0) {
+    if (!(value instanceof Date || typeof value === "number" || typeof value === "string")) {
+      return false;
+    }
+    if (!(value <= record.lte)) return false;
+  }
+  return true;
+}
+function matchesWhere(record, where) {
+  if (!where) return true;
+  if (where.AND && !where.AND.every((clause) => matchesWhere(record, clause))) {
+    return false;
+  }
+  if (where.OR && !where.OR.some((clause) => matchesWhere(record, clause))) {
+    return false;
+  }
+  if (where.NOT && matchesWhere(record, where.NOT)) {
+    return false;
+  }
+  for (const [key, filter] of Object.entries(where)) {
+    if (key === "AND" || key === "OR" || key === "NOT") continue;
+    if (!evaluateFilter(record[key], filter)) return false;
+  }
+  return true;
+}
+function applyDefault(value, field) {
+  if (value !== void 0) return value;
+  if (field.generated === "id") return randomUUID();
+  if (field.generated === "now") return /* @__PURE__ */ new Date();
+  if (typeof field.defaultValue === "function") {
+    return field.defaultValue();
+  }
+  return field.defaultValue;
+}
+function sortRows(rows, orderBy) {
+  if (!orderBy) return rows;
+  const entries = Object.entries(orderBy);
+  if (!entries.length) return rows;
+  return [...rows].sort((left, right) => {
+    for (const [field, direction] of entries) {
+      const a = left[field];
+      const b = right[field];
+      if (a === b) continue;
+      if (a === void 0) return direction === "asc" ? -1 : 1;
+      if (b === void 0) return direction === "asc" ? 1 : -1;
+      if (a == null) return direction === "asc" ? -1 : 1;
+      if (b == null) return direction === "asc" ? 1 : -1;
+      if (a < b) return direction === "asc" ? -1 : 1;
+      if (a > b) return direction === "asc" ? 1 : -1;
+    }
+    return 0;
+  });
+}
+function pageRows(rows, skip, take) {
+  const start = skip ?? 0;
+  const end = take === void 0 ? void 0 : start + take;
+  return rows.slice(start, end);
+}
+function createMemoryDriver(seed) {
+  const state = structuredClone(seed ?? {});
+  function getRows(model2) {
+    const rows = state[model2] ?? [];
+    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);
+  }
+  async function projectRow(schema, model2, row, select) {
+    const modelDefinition = schema.models[model2];
+    const output = {};
+    if (!select) {
+      for (const fieldName of Object.keys(modelDefinition.fields)) {
+        output[fieldName] = row[fieldName];
+      }
+      return output;
+    }
+    for (const [key, value] of Object.entries(select)) {
+      if (value !== true && value === void 0) continue;
+      if (key in modelDefinition.fields && value === true) {
+        output[key] = row[key];
+        continue;
+      }
+      if (key in modelDefinition.relations) {
+        output[key] = await resolveRelation(
+          schema,
+          model2,
+          key,
+          row,
+          value
+        );
+      }
+    }
+    return output;
+  }
+  async function resolveRelation(schema, model2, relationName, row, value) {
+    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);
+      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);
+      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));
+      return Promise.all(
+        filtered2.map(
+          (item) => projectRow(schema, relation.target, item, relationArgs.select)
+        )
+      );
+    }
+    const throughRows = getRows(relation.through).filter(
+      (item) => item[relation.from] === row.id
+    );
+    const targetIds = throughRows.map((item) => item[relation.to]);
+    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));
+    return Promise.all(
+      filtered.map(
+        (item) => projectRow(schema, relation.target, item, relationArgs.select)
+      )
+    );
+  }
+  const driver = {
+    async findMany(schema, model2, args) {
+      const rows = applyQuery(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];
+      if (!row) return null;
+      return projectRow(schema, model2, row, args.select);
+    },
+    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);
+      }
+      getRows(model2).push(nextRow);
+      return projectRow(schema, model2, nextRow, args.select);
+    },
+    async update(schema, model2, args) {
+      const rows = getRows(model2);
+      const row = rows.find((item) => matchesWhere(item, args.where));
+      if (!row) return null;
+      Object.assign(row, args.data);
+      return projectRow(schema, model2, row, args.select);
+    },
+    async delete(_schema, model2, args) {
+      const rows = getRows(model2);
+      const before = rows.length;
+      state[model2] = rows.filter((item) => !matchesWhere(item, args.where));
+      return before - (state[model2]?.length ?? 0);
+    },
+    async transaction(_schema, run) {
+      const snapshot = structuredClone(state);
+      try {
+        return await run(driver);
+      } catch (error) {
+        Object.keys(state).forEach((key) => {
+          delete state[key];
+        });
+        Object.assign(state, snapshot);
+        throw error;
+      }
+    }
+  };
+  return driver;
+}
+
+// src/relations.ts
+function belongsTo(target, config) {
+  return {
+    kind: "belongsTo",
+    target,
+    foreignKey: config.foreignKey
+  };
+}
+function hasOne(target, config) {
+  return {
+    kind: "hasOne",
+    target,
+    foreignKey: config.foreignKey
+  };
+}
+function hasMany(target, config) {
+  return {
+    kind: "hasMany",
+    target,
+    foreignKey: config.foreignKey
+  };
+}
+function manyToMany(target, config) {
+  return {
+    kind: "manyToMany",
+    target,
+    through: config.through,
+    from: config.from,
+    to: config.to
+  };
+}
+
+// src/schema.ts
+function model(config) {
+  return {
+    _tag: "model",
+    table: config.table,
+    fields: config.fields,
+    relations: config.relations ?? {},
+    description: config.description
+  };
+}
+function defineSchema(models) {
+  return {
+    _tag: "schema",
+    models
+  };
+}
+export {
+  FieldBuilder,
+  belongsTo,
+  boolean,
+  createManifest,
+  createMemoryDriver,
+  createOrm,
+  datetime,
+  defineSchema,
+  hasMany,
+  hasOne,
+  id,
+  manyToMany,
+  model,
+  renderDrizzleSchema,
+  renderPrismaSchema,
+  renderSafeSql,
+  replaceGeneratedBlock,
+  string
+};
+//# sourceMappingURL=index.js.map