seedorm 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1063 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors.ts
+var SeedORMError, ValidationError, AdapterError, CollectionNotFoundError, DocumentNotFoundError, UniqueConstraintError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    SeedORMError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SeedORMError";
+      }
+    };
+    ValidationError = class extends SeedORMError {
+      field;
+      reason;
+      constructor(field, reason) {
+        super(`Validation error on "${field}": ${reason}`);
+        this.name = "ValidationError";
+        this.field = field;
+        this.reason = reason;
+      }
+    };
+    AdapterError = class extends SeedORMError {
+      adapter;
+      constructor(adapter, message) {
+        super(`[${adapter}] ${message}`);
+        this.name = "AdapterError";
+        this.adapter = adapter;
+      }
+    };
+    CollectionNotFoundError = class extends SeedORMError {
+      constructor(collection) {
+        super(`Collection "${collection}" not found`);
+        this.name = "CollectionNotFoundError";
+      }
+    };
+    DocumentNotFoundError = class extends SeedORMError {
+      constructor(collection, id) {
+        super(`Document "${id}" not found in "${collection}"`);
+        this.name = "DocumentNotFoundError";
+      }
+    };
+    UniqueConstraintError = class extends SeedORMError {
+      field;
+      value;
+      constructor(collection, field, value) {
+        super(
+          `Unique constraint violation on "${collection}.${field}": value ${JSON.stringify(value)} already exists`
+        );
+        this.name = "UniqueConstraintError";
+        this.field = field;
+        this.value = value;
+      }
+    };
+  }
+});
+
+// src/query/operators.ts
+function applyOperator(key, fieldValue, operand) {
+  const fn = operators[key];
+  if (!fn) throw new Error(`Unknown operator: ${key}`);
+  return fn(fieldValue, operand);
+}
+function isOperatorObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return Object.keys(value).some((k) => k.startsWith("$"));
+}
+var operators, OPERATORS;
+var init_operators = __esm({
+  "src/query/operators.ts"() {
+    "use strict";
+    operators = {
+      $eq: (val, op) => val === op,
+      $ne: (val, op) => val !== op,
+      $gt: (val, op) => {
+        if (typeof val === "number" && typeof op === "number") return val > op;
+        if (typeof val === "string" && typeof op === "string") return val > op;
+        return false;
+      },
+      $gte: (val, op) => {
+        if (typeof val === "number" && typeof op === "number") return val >= op;
+        if (typeof val === "string" && typeof op === "string") return val >= op;
+        return false;
+      },
+      $lt: (val, op) => {
+        if (typeof val === "number" && typeof op === "number") return val < op;
+        if (typeof val === "string" && typeof op === "string") return val < op;
+        return false;
+      },
+      $lte: (val, op) => {
+        if (typeof val === "number" && typeof op === "number") return val <= op;
+        if (typeof val === "string" && typeof op === "string") return val <= op;
+        return false;
+      },
+      $in: (val, op) => {
+        if (!Array.isArray(op)) return false;
+        return op.includes(val);
+      },
+      $nin: (val, op) => {
+        if (!Array.isArray(op)) return true;
+        return !op.includes(val);
+      },
+      $like: (val, op) => {
+        if (typeof val !== "string" || typeof op !== "string") return false;
+        const escaped = op.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const pattern = escaped.replace(/%/g, ".*").replace(/_/g, ".");
+        return new RegExp(`^${pattern}$`, "i").test(val);
+      },
+      $exists: (val, op) => {
+        const exists = val !== void 0 && val !== null;
+        return op ? exists : !exists;
+      }
+    };
+    OPERATORS = Object.keys(operators);
+  }
+});
+
+// src/adapters/postgres/pg-connection.ts
+async function loadPg() {
+  if (pgModule) return pgModule;
+  try {
+    pgModule = await import("pg");
+    return pgModule;
+  } catch {
+    throw new AdapterError(
+      "postgres",
+      'The "pg" package is required for PostgreSQL. Install it with: npm install pg'
+    );
+  }
+}
+var pgModule, PgConnection;
+var init_pg_connection = __esm({
+  "src/adapters/postgres/pg-connection.ts"() {
+    "use strict";
+    init_errors();
+    pgModule = null;
+    PgConnection = class {
+      pool = null;
+      url;
+      constructor(url) {
+        this.url = url;
+      }
+      async connect() {
+        const pg = await loadPg();
+        this.pool = new pg.Pool({ connectionString: this.url });
+        const client = await this.pool.connect();
+        client.release();
+      }
+      async disconnect() {
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+        }
+      }
+      async query(text, params) {
+        if (!this.pool) {
+          throw new AdapterError("postgres", "Not connected");
+        }
+        const result = await this.pool.query(text, params);
+        return { rows: result.rows, rowCount: result.rowCount ?? 0 };
+      }
+    };
+  }
+});
+
+// src/adapters/postgres/pg-query-builder.ts
+function buildSelect(collection, options) {
+  const params = [];
+  let text = `SELECT * FROM "${collection}"`;
+  if (options.filter && Object.keys(options.filter).length > 0) {
+    const where = buildWhere(options.filter, params);
+    text += ` WHERE ${where}`;
+  }
+  if (options.sort) {
+    text += ` ORDER BY ${buildOrderBy(options.sort)}`;
+  }
+  if (options.limit !== void 0) {
+    params.push(options.limit);
+    text += ` LIMIT $${params.length}`;
+  }
+  if (options.offset !== void 0) {
+    params.push(options.offset);
+    text += ` OFFSET $${params.length}`;
+  }
+  return { text, params };
+}
+function buildCount(collection, filter) {
+  const params = [];
+  let text = `SELECT COUNT(*) as count FROM "${collection}"`;
+  if (filter && Object.keys(filter).length > 0) {
+    const where = buildWhere(filter, params);
+    text += ` WHERE ${where}`;
+  }
+  return { text, params };
+}
+function buildWhere(filter, params) {
+  const conditions = [];
+  for (const [field, condition] of Object.entries(filter)) {
+    if (isOperatorObject(condition)) {
+      for (const [op, value] of Object.entries(
+        condition
+      )) {
+        conditions.push(buildOperator(field, op, value, params));
+      }
+    } else {
+      params.push(condition);
+      conditions.push(`"${field}" = $${params.length}`);
+    }
+  }
+  return conditions.join(" AND ");
+}
+function buildOperator(field, op, value, params) {
+  switch (op) {
+    case "$eq":
+      params.push(value);
+      return `"${field}" = $${params.length}`;
+    case "$ne":
+      params.push(value);
+      return `"${field}" != $${params.length}`;
+    case "$gt":
+      params.push(value);
+      return `"${field}" > $${params.length}`;
+    case "$gte":
+      params.push(value);
+      return `"${field}" >= $${params.length}`;
+    case "$lt":
+      params.push(value);
+      return `"${field}" < $${params.length}`;
+    case "$lte":
+      params.push(value);
+      return `"${field}" <= $${params.length}`;
+    case "$in":
+      params.push(value);
+      return `"${field}" = ANY($${params.length})`;
+    case "$nin":
+      params.push(value);
+      return `"${field}" != ALL($${params.length})`;
+    case "$like":
+      params.push(value);
+      return `"${field}" ILIKE $${params.length}`;
+    case "$exists":
+      return value ? `"${field}" IS NOT NULL` : `"${field}" IS NULL`;
+    default:
+      throw new Error(`Unknown operator: ${op}`);
+  }
+}
+function buildOrderBy(sort) {
+  return Object.entries(sort).map(([field, dir]) => `"${field}" ${dir === 1 ? "ASC" : "DESC"}`).join(", ");
+}
+var init_pg_query_builder = __esm({
+  "src/adapters/postgres/pg-query-builder.ts"() {
+    "use strict";
+    init_operators();
+  }
+});
+
+// src/adapters/postgres/postgres-adapter.ts
+var postgres_adapter_exports = {};
+__export(postgres_adapter_exports, {
+  PostgresAdapter: () => PostgresAdapter
+});
+function fieldToSQLType(field) {
+  switch (field.type) {
+    case "string":
+      return field.maxLength ? `VARCHAR(${field.maxLength})` : "TEXT";
+    case "number":
+      return "DOUBLE PRECISION";
+    case "boolean":
+      return "BOOLEAN";
+    case "date":
+      return "TIMESTAMPTZ";
+    case "json":
+    case "array":
+      return "JSONB";
+    default:
+      return "TEXT";
+  }
+}
+var PostgresAdapter;
+var init_postgres_adapter = __esm({
+  "src/adapters/postgres/postgres-adapter.ts"() {
+    "use strict";
+    init_pg_connection();
+    init_pg_query_builder();
+    PostgresAdapter = class {
+      conn;
+      constructor(url) {
+        this.conn = new PgConnection(url);
+      }
+      async connect() {
+        await this.conn.connect();
+      }
+      async disconnect() {
+        await this.conn.disconnect();
+      }
+      async createCollection(collection, schema) {
+        const columns = [
+          `"id" TEXT PRIMARY KEY`,
+          `"createdAt" TIMESTAMPTZ NOT NULL DEFAULT NOW()`,
+          `"updatedAt" TIMESTAMPTZ NOT NULL DEFAULT NOW()`
+        ];
+        for (const [name, def] of Object.entries(schema)) {
+          let col = `"${name}" ${fieldToSQLType(def)}`;
+          if (def.required) col += " NOT NULL";
+          if (def.unique) col += " UNIQUE";
+          columns.push(col);
+        }
+        await this.conn.query(
+          `CREATE TABLE IF NOT EXISTS "${collection}" (${columns.join(", ")})`
+        );
+        for (const [name, def] of Object.entries(schema)) {
+          if (def.index && !def.unique) {
+            await this.conn.query(
+              `CREATE INDEX IF NOT EXISTS "idx_${collection}_${name}" ON "${collection}" ("${name}")`
+            );
+          }
+        }
+      }
+      async dropCollection(collection) {
+        await this.conn.query(`DROP TABLE IF EXISTS "${collection}" CASCADE`);
+      }
+      async listCollections() {
+        const { rows } = await this.conn.query(
+          `SELECT tablename FROM pg_tables WHERE schemaname = 'public'`
+        );
+        return rows.map((r) => r.tablename);
+      }
+      async insert(collection, doc) {
+        const keys = Object.keys(doc);
+        const cols = keys.map((k) => `"${k}"`).join(", ");
+        const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
+        const values = keys.map((k) => {
+          const v = doc[k];
+          return typeof v === "object" && v !== null && !(v instanceof Date) ? JSON.stringify(v) : v;
+        });
+        const { rows } = await this.conn.query(
+          `INSERT INTO "${collection}" (${cols}) VALUES (${placeholders}) RETURNING *`,
+          values
+        );
+        return rows[0];
+      }
+      async findById(collection, id) {
+        const { rows } = await this.conn.query(
+          `SELECT * FROM "${collection}" WHERE "id" = $1`,
+          [id]
+        );
+        return rows[0] ?? null;
+      }
+      async find(collection, options) {
+        const q = buildSelect(collection, options);
+        const { rows } = await this.conn.query(q.text, q.params);
+        return rows;
+      }
+      async count(collection, filter) {
+        const q = buildCount(collection, filter);
+        const { rows } = await this.conn.query(
+          q.text,
+          q.params
+        );
+        return parseInt(rows[0].count, 10);
+      }
+      async update(collection, id, data) {
+        const entries = Object.entries(data).filter(([k]) => k !== "id");
+        if (entries.length === 0) return this.findById(collection, id);
+        const sets = entries.map(([k], i) => `"${k}" = $${i + 1}`).join(", ");
+        const values = entries.map(
+          ([, v]) => typeof v === "object" && v !== null && !(v instanceof Date) ? JSON.stringify(v) : v
+        );
+        values.push(id);
+        const { rows } = await this.conn.query(
+          `UPDATE "${collection}" SET ${sets} WHERE "id" = $${values.length} RETURNING *`,
+          values
+        );
+        return rows[0] ?? null;
+      }
+      async delete(collection, id) {
+        const { rowCount } = await this.conn.query(
+          `DELETE FROM "${collection}" WHERE "id" = $1`,
+          [id]
+        );
+        return rowCount > 0;
+      }
+      async deleteMany(collection, filter) {
+        const q = buildSelect(collection, { filter });
+        const deleteText = q.text.replace(/^SELECT \* FROM/, "DELETE FROM");
+        const { rowCount } = await this.conn.query(deleteText, q.params);
+        return rowCount;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AdapterError: () => AdapterError,
+  CollectionNotFoundError: () => CollectionNotFoundError,
+  DocumentNotFoundError: () => DocumentNotFoundError,
+  JsonAdapter: () => JsonAdapter,
+  Model: () => Model,
+  PostgresAdapter: () => PostgresAdapter,
+  SeedORM: () => SeedORM,
+  SeedORMError: () => SeedORMError,
+  UniqueConstraintError: () => UniqueConstraintError,
+  ValidationError: () => ValidationError,
+  normalizeSchema: () => normalizeSchema,
+  validateDocument: () => validateDocument
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/seedorm.ts
+init_errors();
+
+// src/model/model.ts
+var import_nanoid = require("nanoid");
+init_errors();
+
+// src/model/schema.ts
+init_errors();
+
+// src/model/field-types.ts
+function validateFieldType(value, type) {
+  if (value === void 0 || value === null) return null;
+  switch (type) {
+    case "string":
+      if (typeof value !== "string") return `expected string, got ${typeof value}`;
+      break;
+    case "number":
+      if (typeof value !== "number" || Number.isNaN(value))
+        return `expected number, got ${typeof value}`;
+      break;
+    case "boolean":
+      if (typeof value !== "boolean")
+        return `expected boolean, got ${typeof value}`;
+      break;
+    case "date":
+      if (typeof value === "string") {
+        if (Number.isNaN(Date.parse(value))) return `invalid date string`;
+      } else if (!(value instanceof Date)) {
+        return `expected date string or Date, got ${typeof value}`;
+      }
+      break;
+    case "json":
+      break;
+    case "array":
+      if (!Array.isArray(value)) return `expected array, got ${typeof value}`;
+      break;
+    default:
+      return `unknown type: ${type}`;
+  }
+  return null;
+}
+function coerceFieldValue(value, type) {
+  if (value === void 0 || value === null) return value;
+  if (type === "date" && value instanceof Date) {
+    return value.toISOString();
+  }
+  return value;
+}
+
+// src/model/schema.ts
+function normalizeSchema(schema) {
+  const normalized = {};
+  for (const [field, def] of Object.entries(schema)) {
+    if (typeof def === "string") {
+      normalized[field] = {
+        type: def,
+        required: false,
+        unique: false,
+        index: false
+      };
+    } else {
+      const d = def;
+      normalized[field] = {
+        type: d.type,
+        required: d.required ?? false,
+        unique: d.unique ?? false,
+        index: d.index ?? d.unique ?? false,
+        ...d.default !== void 0 && { default: d.default },
+        ...d.minLength !== void 0 && { minLength: d.minLength },
+        ...d.maxLength !== void 0 && { maxLength: d.maxLength },
+        ...d.min !== void 0 && { min: d.min },
+        ...d.max !== void 0 && { max: d.max },
+        ...d.enum !== void 0 && { enum: d.enum }
+      };
+    }
+  }
+  return normalized;
+}
+function validateDocument(data, schema, isUpdate = false) {
+  const result = {};
+  for (const [field, def] of Object.entries(schema)) {
+    let value = data[field];
+    if (value === void 0 && def.default !== void 0 && !isUpdate) {
+      value = typeof def.default === "function" ? def.default() : def.default;
+    }
+    if (!isUpdate && def.required && (value === void 0 || value === null)) {
+      throw new ValidationError(field, "field is required");
+    }
+    if (value === void 0) continue;
+    const typeErr = validateFieldType(value, def.type);
+    if (typeErr) throw new ValidationError(field, typeErr);
+    if (def.type === "string" && typeof value === "string") {
+      if (def.minLength !== void 0 && value.length < def.minLength) {
+        throw new ValidationError(
+          field,
+          `minimum length is ${def.minLength}, got ${value.length}`
+        );
+      }
+      if (def.maxLength !== void 0 && value.length > def.maxLength) {
+        throw new ValidationError(
+          field,
+          `maximum length is ${def.maxLength}, got ${value.length}`
+        );
+      }
+    }
+    if (def.type === "number" && typeof value === "number") {
+      if (def.min !== void 0 && value < def.min) {
+        throw new ValidationError(field, `minimum value is ${def.min}`);
+      }
+      if (def.max !== void 0 && value > def.max) {
+        throw new ValidationError(field, `maximum value is ${def.max}`);
+      }
+    }
+    if (def.enum && !def.enum.includes(value)) {
+      throw new ValidationError(
+        field,
+        `value must be one of: ${def.enum.join(", ")}`
+      );
+    }
+    result[field] = coerceFieldValue(value, def.type);
+  }
+  if (isUpdate) {
+    for (const [key, val] of Object.entries(data)) {
+      if (!(key in schema) && val !== void 0) {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+
+// src/model/model.ts
+var Model = class {
+  name;
+  collection;
+  schema;
+  prefix;
+  adapter;
+  timestamps;
+  constructor(definition, adapter) {
+    this.name = definition.name;
+    this.collection = definition.collection;
+    this.schema = normalizeSchema(definition.schema);
+    this.prefix = definition.prefix ?? definition.collection.slice(0, 3);
+    this.adapter = adapter;
+    this.timestamps = definition.timestamps !== false;
+  }
+  async init() {
+    await this.adapter.createCollection(this.collection, this.schema);
+  }
+  generateId() {
+    return `${this.prefix}_${(0, import_nanoid.nanoid)(12)}`;
+  }
+  async create(data) {
+    const validated = validateDocument(data, this.schema);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = {
+      ...validated,
+      id: this.generateId(),
+      createdAt: now,
+      updatedAt: now
+    };
+    return this.adapter.insert(this.collection, doc);
+  }
+  async createMany(items) {
+    const results = [];
+    for (const item of items) {
+      results.push(await this.create(item));
+    }
+    return results;
+  }
+  async findById(id) {
+    return this.adapter.findById(this.collection, id);
+  }
+  async findByIdOrThrow(id) {
+    const doc = await this.findById(id);
+    if (!doc) throw new DocumentNotFoundError(this.collection, id);
+    return doc;
+  }
+  async findOne(filter) {
+    const results = await this.adapter.find(this.collection, {
+      filter,
+      limit: 1
+    });
+    return results[0] ?? null;
+  }
+  async find(options = {}) {
+    return this.adapter.find(this.collection, options);
+  }
+  async findAll() {
+    return this.adapter.find(this.collection, {});
+  }
+  async count(filter) {
+    return this.adapter.count(this.collection, filter);
+  }
+  async update(id, data) {
+    const validated = validateDocument(data, this.schema, true);
+    if (this.timestamps) {
+      validated.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return this.adapter.update(this.collection, id, validated);
+  }
+  async updateOrThrow(id, data) {
+    const doc = await this.update(id, data);
+    if (!doc) throw new DocumentNotFoundError(this.collection, id);
+    return doc;
+  }
+  async delete(id) {
+    return this.adapter.delete(this.collection, id);
+  }
+  async deleteMany(filter) {
+    return this.adapter.deleteMany(this.collection, filter);
+  }
+};
+
+// src/adapters/json/json-adapter.ts
+init_errors();
+
+// src/query/filter.ts
+init_operators();
+function matchesFilter(doc, filter) {
+  for (const [field, condition] of Object.entries(filter)) {
+    const value = doc[field];
+    if (isOperatorObject(condition)) {
+      for (const [op, operand] of Object.entries(
+        condition
+      )) {
+        if (!applyOperator(op, value, operand)) return false;
+      }
+    } else {
+      if (value !== condition) return false;
+    }
+  }
+  return true;
+}
+function sortDocuments(docs, sort) {
+  const entries = Object.entries(sort);
+  return [...docs].sort((a, b) => {
+    for (const [field, dir] of entries) {
+      const av = a[field];
+      const bv = b[field];
+      if (av === bv) continue;
+      if (av === void 0 || av === null) return dir;
+      if (bv === void 0 || bv === null) return -dir;
+      if (av < bv) return -dir;
+      if (av > bv) return dir;
+    }
+    return 0;
+  });
+}
+function applyFindOptions(docs, options) {
+  let result = docs;
+  if (options.filter) {
+    result = result.filter((doc) => matchesFilter(doc, options.filter));
+  }
+  if (options.sort) {
+    result = sortDocuments(result, options.sort);
+  }
+  if (options.offset) {
+    result = result.slice(options.offset);
+  }
+  if (options.limit !== void 0) {
+    result = result.slice(0, options.limit);
+  }
+  return result;
+}
+function countWithFilter(docs, filter) {
+  if (!filter) return docs.length;
+  return docs.filter((doc) => matchesFilter(doc, filter)).length;
+}
+
+// src/adapters/json/file-engine.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_write_file_atomic = __toESM(require("write-file-atomic"), 1);
+var FileEngine = class {
+  filePath;
+  data = {};
+  writeQueue = Promise.resolve();
+  dirty = false;
+  constructor(filePath) {
+    this.filePath = path.resolve(filePath);
+  }
+  async load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, "utf-8");
+      this.data = JSON.parse(raw);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this.data = {};
+        await this.flush();
+      } else {
+        throw err;
+      }
+    }
+  }
+  getData() {
+    return this.data;
+  }
+  getCollection(name) {
+    if (!this.data[name]) {
+      this.data[name] = [];
+    }
+    return this.data[name];
+  }
+  hasCollection(name) {
+    return name in this.data;
+  }
+  createCollection(name) {
+    if (!this.data[name]) {
+      this.data[name] = [];
+    }
+  }
+  dropCollection(name) {
+    delete this.data[name];
+  }
+  listCollections() {
+    return Object.keys(this.data);
+  }
+  markDirty() {
+    this.dirty = true;
+  }
+  async flush() {
+    this.writeQueue = this.writeQueue.then(async () => {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      await (0, import_write_file_atomic.default)(
+        this.filePath,
+        JSON.stringify(this.data, null, 2) + "\n"
+      );
+      this.dirty = false;
+    });
+    return this.writeQueue;
+  }
+  async flushIfDirty() {
+    if (this.dirty) {
+      await this.flush();
+    }
+  }
+};
+
+// src/adapters/json/indexer.ts
+init_errors();
+var Indexer = class {
+  indexes = /* @__PURE__ */ new Map();
+  // collection → field → index
+  setupIndex(collection, field, unique, docs) {
+    if (!this.indexes.has(collection)) {
+      this.indexes.set(collection, /* @__PURE__ */ new Map());
+    }
+    const colIndexes = this.indexes.get(collection);
+    const idx = { field, unique, map: /* @__PURE__ */ new Map() };
+    for (const doc of docs) {
+      const val = doc[field];
+      if (val === void 0 || val === null) continue;
+      if (!idx.map.has(val)) {
+        idx.map.set(val, /* @__PURE__ */ new Set());
+      }
+      idx.map.get(val).add(doc.id);
+    }
+    colIndexes.set(field, idx);
+  }
+  onInsert(collection, doc) {
+    const colIndexes = this.indexes.get(collection);
+    if (!colIndexes) return;
+    for (const [, idx] of colIndexes) {
+      const val = doc[idx.field];
+      if (val === void 0 || val === null) continue;
+      if (idx.unique && idx.map.has(val) && idx.map.get(val).size > 0) {
+        throw new UniqueConstraintError(collection, idx.field, val);
+      }
+      if (!idx.map.has(val)) {
+        idx.map.set(val, /* @__PURE__ */ new Set());
+      }
+      idx.map.get(val).add(doc.id);
+    }
+  }
+  onUpdate(collection, oldDoc, newDoc) {
+    const colIndexes = this.indexes.get(collection);
+    if (!colIndexes) return;
+    for (const [, idx] of colIndexes) {
+      const oldVal = oldDoc[idx.field];
+      const newVal = newDoc[idx.field];
+      if (oldVal === newVal) continue;
+      if (oldVal !== void 0 && oldVal !== null) {
+        idx.map.get(oldVal)?.delete(oldDoc.id);
+      }
+      if (newVal !== void 0 && newVal !== null) {
+        if (idx.unique && idx.map.has(newVal) && idx.map.get(newVal).size > 0) {
+          throw new UniqueConstraintError(collection, idx.field, newVal);
+        }
+        if (!idx.map.has(newVal)) {
+          idx.map.set(newVal, /* @__PURE__ */ new Set());
+        }
+        idx.map.get(newVal).add(newDoc.id);
+      }
+    }
+  }
+  onDelete(collection, doc) {
+    const colIndexes = this.indexes.get(collection);
+    if (!colIndexes) return;
+    for (const [, idx] of colIndexes) {
+      const val = doc[idx.field];
+      if (val !== void 0 && val !== null) {
+        idx.map.get(val)?.delete(doc.id);
+      }
+    }
+  }
+  findByValue(collection, field, value) {
+    return this.indexes.get(collection)?.get(field)?.map.get(value);
+  }
+  dropCollection(collection) {
+    this.indexes.delete(collection);
+  }
+};
+
+// src/adapters/json/json-adapter.ts
+var JsonAdapter = class {
+  engine;
+  indexer = new Indexer();
+  schemas = /* @__PURE__ */ new Map();
+  constructor(filePath) {
+    this.engine = new FileEngine(filePath);
+  }
+  async connect() {
+    await this.engine.load();
+  }
+  async disconnect() {
+    await this.engine.flushIfDirty();
+  }
+  async createCollection(collection, schema) {
+    this.engine.createCollection(collection);
+    this.schemas.set(collection, schema);
+    for (const [field, def] of Object.entries(schema)) {
+      if (def.index || def.unique) {
+        this.indexer.setupIndex(
+          collection,
+          field,
+          def.unique,
+          this.engine.getCollection(collection)
+        );
+      }
+    }
+    await this.engine.flush();
+  }
+  async dropCollection(collection) {
+    this.engine.dropCollection(collection);
+    this.indexer.dropCollection(collection);
+    this.schemas.delete(collection);
+    await this.engine.flush();
+  }
+  async listCollections() {
+    return this.engine.listCollections();
+  }
+  async insert(collection, doc) {
+    const docs = this.getCollectionOrThrow(collection);
+    this.indexer.onInsert(collection, doc);
+    docs.push(doc);
+    this.engine.markDirty();
+    await this.engine.flush();
+    return doc;
+  }
+  async findById(collection, id) {
+    const docs = this.getCollectionOrThrow(collection);
+    return docs.find((d) => d.id === id) ?? null;
+  }
+  async find(collection, options) {
+    const docs = this.getCollectionOrThrow(collection);
+    return applyFindOptions(docs, options);
+  }
+  async count(collection, filter) {
+    const docs = this.getCollectionOrThrow(collection);
+    return countWithFilter(docs, filter);
+  }
+  async update(collection, id, data) {
+    const docs = this.getCollectionOrThrow(collection);
+    const index = docs.findIndex((d) => d.id === id);
+    if (index === -1) return null;
+    const oldDoc = docs[index];
+    const newDoc = { ...oldDoc, ...data, id: oldDoc.id };
+    this.indexer.onUpdate(collection, oldDoc, newDoc);
+    docs[index] = newDoc;
+    this.engine.markDirty();
+    await this.engine.flush();
+    return newDoc;
+  }
+  async delete(collection, id) {
+    const docs = this.getCollectionOrThrow(collection);
+    const index = docs.findIndex((d) => d.id === id);
+    if (index === -1) return false;
+    this.indexer.onDelete(collection, docs[index]);
+    docs.splice(index, 1);
+    this.engine.markDirty();
+    await this.engine.flush();
+    return true;
+  }
+  async deleteMany(collection, filter) {
+    const docs = this.getCollectionOrThrow(collection);
+    const matching = applyFindOptions(docs, { filter });
+    for (const doc of matching) {
+      this.indexer.onDelete(collection, doc);
+    }
+    const ids = new Set(matching.map((d) => d.id));
+    const remaining = docs.filter((d) => !ids.has(d.id));
+    const deleted = docs.length - remaining.length;
+    docs.length = 0;
+    docs.push(...remaining);
+    if (deleted > 0) {
+      this.engine.markDirty();
+      await this.engine.flush();
+    }
+    return deleted;
+  }
+  getCollectionOrThrow(collection) {
+    if (!this.engine.hasCollection(collection)) {
+      throw new CollectionNotFoundError(collection);
+    }
+    return this.engine.getCollection(collection);
+  }
+};
+
+// src/seedorm.ts
+var path2 = __toESM(require("path"), 1);
+var SeedORM = class {
+  config;
+  adapter = null;
+  models = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor(config) {
+    this.config = {
+      adapter: config?.adapter ?? { adapter: "json", path: "./data" },
+      migrationsDir: config?.migrationsDir ?? "./migrations"
+    };
+  }
+  async createAdapter(adapterConfig) {
+    switch (adapterConfig.adapter) {
+      case "json": {
+        const dbPath = path2.resolve(
+          adapterConfig.path ?? "./data",
+          "seedorm.json"
+        );
+        return new JsonAdapter(dbPath);
+      }
+      case "postgres": {
+        const { PostgresAdapter: PostgresAdapter2 } = await Promise.resolve().then(() => (init_postgres_adapter(), postgres_adapter_exports));
+        return new PostgresAdapter2(adapterConfig.url);
+      }
+      case "mysql":
+        throw new SeedORMError(
+          'MySQL adapter requires the "mysql2" package. Install it with: npm install mysql2'
+        );
+      default:
+        throw new SeedORMError(
+          `Unknown adapter: ${adapterConfig.adapter}`
+        );
+    }
+  }
+  async connect() {
+    if (this.connected) return;
+    this.adapter = await this.createAdapter(this.config.adapter);
+    await this.adapter.connect();
+    this.connected = true;
+    for (const model of this.models.values()) {
+      await model.init();
+    }
+  }
+  async disconnect() {
+    if (!this.connected || !this.adapter) return;
+    await this.adapter.disconnect();
+    this.connected = false;
+    this.adapter = null;
+  }
+  model(definition) {
+    if (this.models.has(definition.name)) {
+      return this.models.get(definition.name);
+    }
+    if (!this.adapter) {
+      throw new SeedORMError(
+        "Not connected. Call db.connect() before defining models."
+      );
+    }
+    const model = new Model(definition, this.adapter);
+    this.models.set(definition.name, model);
+    return model;
+  }
+  getModel(name) {
+    return this.models.get(name);
+  }
+  getAdapter() {
+    if (!this.adapter) {
+      throw new SeedORMError("Not connected.");
+    }
+    return this.adapter;
+  }
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/index.ts
+init_postgres_adapter();
+init_errors();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdapterError,
+  CollectionNotFoundError,
+  DocumentNotFoundError,
+  JsonAdapter,
+  Model,
+  PostgresAdapter,
+  SeedORM,
+  SeedORMError,
+  UniqueConstraintError,
+  ValidationError,
+  normalizeSchema,
+  validateDocument
+});
+//# sourceMappingURL=index.cjs.map