@datrix/adapter-json 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2321 @@
+// src/adapter.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { validateQueryObject } from "@datrix/core";
+
+// src/runner.ts
+import {
+  throwInvalidRelationWhereSyntax,
+  throwInvalidWhereField
+} from "@datrix/core";
+var JsonQueryRunner = class {
+  constructor(table, adapter, schema) {
+    this.table = table;
+    this.adapter = adapter;
+    this.schema = schema;
+  }
+  schema;
+  get tableData() {
+    return this.table;
+  }
+  get tableSchema() {
+    return this.schema;
+  }
+  get adapterRef() {
+    return this.adapter;
+  }
+  async run(query) {
+    let result = this.table.data;
+    if (query.where) {
+      const matchResults = await Promise.all(
+        result.map((item) => this.match(item, query.where))
+      );
+      result = result.filter((_, i) => matchResults[i]);
+    } else if (query.type === "select" && query.orderBy && query.orderBy.length > 0) {
+      result = [...result];
+    }
+    if (query.type === "count") {
+      return result;
+    }
+    if (query.select || query.distinct) {
+      result = this.project(result, query.select, query.distinct);
+    }
+    if (query.orderBy && query.orderBy.length > 0) {
+      result.sort(
+        (a, b) => this.sort(
+          a,
+          b,
+          query.orderBy
+        )
+      );
+    }
+    const offset = query.offset ?? 0;
+    if (query.limit !== void 0) {
+      result = result.slice(offset, offset + query.limit);
+    } else if (offset > 0) {
+      result = result.slice(offset);
+    }
+    return result;
+  }
+  /**
+   * Run query without projection (for populate workflow)
+   * Applies WHERE, ORDER BY, OFFSET, LIMIT but keeps all fields
+   */
+  async filterAndSort(query) {
+    let result = this.table.data;
+    if (query.where) {
+      const matchResults = await Promise.all(
+        result.map((item) => this.match(item, query.where))
+      );
+      result = result.filter((_, i) => matchResults[i]);
+    } else if (query.orderBy && query.orderBy.length > 0) {
+      result = [...result];
+    }
+    if (query.orderBy && query.orderBy.length > 0) {
+      result.sort(
+        (a, b) => this.sort(
+          a,
+          b,
+          query.orderBy
+        )
+      );
+    }
+    const offset = query.offset ?? 0;
+    if (query.limit !== void 0) {
+      result = result.slice(offset, offset + query.limit);
+    } else if (offset > 0) {
+      result = result.slice(offset);
+    }
+    return result;
+  }
+  // Exposed for Adapter's RETURNING clause usage
+  projectData(data, select, distinct) {
+    return this.project(data, select, distinct);
+  }
+  project(data, select, distinct) {
+    let result = data;
+    if (select && select !== "*") {
+      result = data.map((item) => {
+        const projected = {};
+        for (const field of select) {
+          projected[field] = item[field];
+          if (projected[field] === void 0) {
+            projected[field] = null;
+          }
+        }
+        return projected;
+      });
+    }
+    if (distinct) {
+      const seen = /* @__PURE__ */ new Set();
+      result = result.filter((item) => {
+        const key = JSON.stringify(item);
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+    }
+    return result;
+  }
+  /**
+   * Match WHERE clause against an item
+   *
+   * **NEW:** Now supports nested relation WHERE queries!
+   *
+   * @param item - The record to match against
+   * @param where - WHERE clause (may contain nested relation conditions)
+   * @param overrideSchema - Optional schema to use instead of this.table.schema (for nested relation matching)
+   * @returns True if item matches all conditions
+   *
+   * @example
+   * ```ts
+   * // Simple WHERE
+   * await match(item, { price: { $gt: 10 } })
+   *
+   * // Nested relation WHERE
+   * await match(item, {
+   *   author: {  // Relation field
+   *     verified: { $eq: true }
+   *   }
+   * })
+   * ```
+   */
+  async match(item, where, overrideSchema) {
+    const schema = overrideSchema ?? this.schema;
+    for (const [key, value] of Object.entries(where)) {
+      if (key === "$and") {
+        const results = await Promise.all(
+          value.map(
+            (cond) => this.match(item, cond, schema)
+          )
+        );
+        if (!results.every((r) => r)) return false;
+        continue;
+      }
+      if (key === "$or") {
+        const results = await Promise.all(
+          value.map(
+            (cond) => this.match(item, cond, schema)
+          )
+        );
+        if (!results.some((r) => r)) return false;
+        continue;
+      }
+      if (key === "$not") {
+        if (await this.match(item, value, schema))
+          return false;
+        continue;
+      }
+      const fieldDef = schema?.fields?.[key];
+      if (fieldDef?.type === "relation") {
+        const matched = await this.matchRelation(
+          item,
+          key,
+          value,
+          fieldDef
+        );
+        if (!matched) {
+          return false;
+        }
+        continue;
+      }
+      if (schema && !schema.fields[key]) {
+        throwInvalidWhereField({
+          adapter: "json",
+          field: key,
+          schemaName: schema.name,
+          availableFields: Object.keys(schema.fields)
+        });
+      }
+      const itemValue = item[key];
+      if (value === null) {
+        if (itemValue !== null && itemValue !== void 0) return false;
+      } else if (typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+        const isOperators = Object.keys(value).some((k) => k.startsWith("$"));
+        if (isOperators) {
+          if (!this.matchOperators(itemValue, value, key))
+            return false;
+        } else {
+          if (!this.compareValues(itemValue, value, key)) return false;
+        }
+      } else {
+        if (!this.compareValues(itemValue, value, key)) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Match nested relation WHERE
+   *
+   * Loads the related record(s) and recursively matches the nested WHERE clause.
+   *
+   * @param item - Current record
+   * @param relationName - Name of the relation field
+   * @param relationWhere - Nested WHERE clause for the relation
+   * @param relationField - Relation field definition
+   * @returns True if relation matches
+   */
+  async matchRelation(item, relationName, relationWhere, relationField) {
+    const foreignKey = relationField.foreignKey;
+    const targetModelName = relationField.model;
+    const kind = relationField.kind;
+    if (typeof relationWhere === "object" && relationWhere !== null) {
+      const keys = Object.keys(relationWhere);
+      const logicalOps = /* @__PURE__ */ new Set(["$and", "$or", "$not"]);
+      const hasOnlyComparisonOperators = keys.length > 0 && keys.every((k) => k.startsWith("$")) && !keys.some((k) => logicalOps.has(k));
+      if (hasOnlyComparisonOperators) {
+        throwInvalidRelationWhereSyntax({
+          adapter: "json",
+          relationName,
+          schemaName: this.schema?.name ?? "unknown",
+          foreignKey
+        });
+      }
+    }
+    if (kind === "belongsTo" || kind === "hasOne") {
+      const relatedId = item[foreignKey];
+      if (relatedId === null || relatedId === void 0) {
+        return false;
+      }
+      const targetSchema = await this.adapter.getSchemaByModelName(targetModelName);
+      if (!targetSchema) {
+        return false;
+      }
+      const relatedRecord = await this.loadRelatedRecord(
+        targetModelName,
+        relatedId
+      );
+      if (!relatedRecord) {
+        return false;
+      }
+      return await this.match(relatedRecord, relationWhere, targetSchema);
+    }
+    if (kind === "hasMany") {
+      const sourceId = item["id"];
+      if (sourceId === null || sourceId === void 0) {
+        return false;
+      }
+      const targetSchema = await this.adapter.getSchemaByModelName(targetModelName);
+      if (!targetSchema) {
+        return false;
+      }
+      const targetTable = targetSchema.tableName ?? targetModelName.toLowerCase();
+      const targetTableData = await this.adapter.getCachedTable(targetTable);
+      if (!targetTableData) {
+        return false;
+      }
+      const relatedRecords = targetTableData.data.filter(
+        (r) => r[foreignKey] === sourceId || r[foreignKey] === Number(sourceId)
+      );
+      for (const related of relatedRecords) {
+        const matches = await this.match(related, relationWhere, targetSchema);
+        if (matches) return true;
+      }
+      return false;
+    }
+    if (kind === "manyToMany") {
+      const junctionTableName = relationField.through;
+      if (!junctionTableName) {
+        return false;
+      }
+      const sourceId = item["id"];
+      if (sourceId === null || sourceId === void 0) {
+        return false;
+      }
+      const junctionTableData = await this.adapter.getCachedTable(junctionTableName);
+      if (!junctionTableData) {
+        return false;
+      }
+      const currentModelName = this.schema?.name ?? "";
+      const sourceFK = `${currentModelName}Id`;
+      const targetFK = `${targetModelName}Id`;
+      const targetIds = junctionTableData.data.filter((row) => {
+        const rowSourceId = row[sourceFK];
+        return rowSourceId === sourceId || rowSourceId === Number(sourceId);
+      }).map((row) => {
+        const rawId = row[targetFK];
+        return typeof rawId === "string" ? Number(rawId) : rawId;
+      }).filter((id) => id !== null && id !== void 0);
+      if (targetIds.length === 0) {
+        return false;
+      }
+      const targetSchema = await this.adapter.getSchemaByModelName(targetModelName);
+      if (!targetSchema) {
+        return false;
+      }
+      const targetTable = targetSchema.tableName ?? targetModelName.toLowerCase();
+      const targetTableData = await this.adapter.getCachedTable(targetTable);
+      if (!targetTableData) {
+        return false;
+      }
+      const targetRecords = targetTableData.data.filter((r) => targetIds.includes(r["id"]));
+      for (const target of targetRecords) {
+        const matches = await this.match(target, relationWhere, targetSchema);
+        if (matches) return true;
+      }
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Load a related record from adapter's cache
+   *
+   * Uses getCachedTable which reads from cache or disk if needed.
+   *
+   * @param modelName - Target model name
+   * @param id - Record ID to load
+   * @returns Related record or null
+   */
+  async loadRelatedRecord(modelName, id) {
+    try {
+      const targetSchema = await this.adapter.getSchemaByModelName(modelName);
+      if (!targetSchema) {
+        return null;
+      }
+      const targetTable = targetSchema.tableName ?? modelName.toLowerCase();
+      const tableData = await this.adapter.getCachedTable(targetTable);
+      if (!tableData) {
+        return null;
+      }
+      const relatedData = tableData.data;
+      const record = relatedData.find((r) => r["id"] === id);
+      return record ?? null;
+    } catch {
+      return null;
+    }
+  }
+  compareValues(itemValue, queryValue, fieldName) {
+    const schema = this.schema;
+    const fieldDef = schema?.fields?.[fieldName];
+    if (!fieldDef) {
+      return itemValue === queryValue;
+    }
+    const fieldType = fieldDef.type;
+    if (fieldType === "number") {
+      const itemNum = Number(itemValue);
+      const queryNum = Number(queryValue);
+      return !isNaN(itemNum) && !isNaN(queryNum) && itemNum === queryNum;
+    }
+    if (fieldType === "string") {
+      return String(itemValue) === String(queryValue);
+    }
+    if (fieldType === "boolean") {
+      return Boolean(itemValue) === Boolean(queryValue);
+    }
+    return itemValue === queryValue;
+  }
+  matchOperators(value, operators, fieldName) {
+    for (const [op, opValue] of Object.entries(operators)) {
+      switch (op) {
+        case "$eq":
+          if (!this.compareValues(value, opValue, fieldName)) return false;
+          break;
+        case "$ne":
+          if (this.compareValues(value, opValue, fieldName)) return false;
+          break;
+        case "$gt": {
+          if (value === null || value === void 0) return false;
+          const coercedVal = this.coerceForComparison(value, fieldName);
+          const coercedOp = this.coerceForComparison(opValue, fieldName);
+          if (!(coercedVal > coercedOp)) return false;
+          break;
+        }
+        case "$gte": {
+          if (value === null || value === void 0) return false;
+          const coercedVal = this.coerceForComparison(value, fieldName);
+          const coercedOp = this.coerceForComparison(opValue, fieldName);
+          if (!(coercedVal >= coercedOp)) return false;
+          break;
+        }
+        case "$lt": {
+          if (value === null || value === void 0) return false;
+          const coercedVal = this.coerceForComparison(value, fieldName);
+          const coercedOp = this.coerceForComparison(opValue, fieldName);
+          if (!(coercedVal < coercedOp)) return false;
+          break;
+        }
+        case "$lte": {
+          if (value === null || value === void 0) return false;
+          const coercedVal = this.coerceForComparison(value, fieldName);
+          const coercedOp = this.coerceForComparison(opValue, fieldName);
+          if (!(coercedVal <= coercedOp)) return false;
+          break;
+        }
+        case "$in": {
+          const coercedValue = this.coerceForComparison(value, fieldName);
+          const coercedArray = opValue.map(
+            (v) => this.coerceForComparison(v, fieldName)
+          );
+          if (!coercedArray.includes(coercedValue)) return false;
+          break;
+        }
+        case "$nin": {
+          const coercedValue = this.coerceForComparison(value, fieldName);
+          const coercedArray = opValue.map(
+            (v) => this.coerceForComparison(v, fieldName)
+          );
+          if (coercedArray.includes(coercedValue)) return false;
+          break;
+        }
+        case "$exists":
+          if (opValue && (value === void 0 || value === null)) return false;
+          if (!opValue && value !== void 0 && value !== null) return false;
+          break;
+        case "$null":
+          if (opValue && value !== null && value !== void 0) return false;
+          if (!opValue && (value === null || value === void 0)) return false;
+          break;
+        case "$like":
+        case "$ilike": {
+          const pattern = opValue.replace(/%/g, ".*").replace(/_/g, ".");
+          const flags = op === "$ilike" ? "i" : "";
+          const regex = new RegExp(`^${pattern}$`, flags);
+          if (!regex.test(String(value ?? ""))) return false;
+          break;
+        }
+        case "$contains":
+          if (!String(value ?? "").includes(String(opValue))) return false;
+          break;
+        case "$notContains":
+          if (String(value ?? "").includes(String(opValue))) return false;
+          break;
+        case "$startsWith":
+          if (!String(value ?? "").startsWith(String(opValue))) return false;
+          break;
+        case "$endsWith":
+          if (!String(value ?? "").endsWith(String(opValue))) return false;
+          break;
+        case "$notNull":
+          if (opValue && (value === null || value === void 0)) return false;
+          if (!opValue && value !== null && value !== void 0) return false;
+          break;
+      }
+    }
+    return true;
+  }
+  coerceForComparison(value, fieldName) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    const schema = this.schema;
+    const fieldDef = schema?.fields?.[fieldName];
+    if (!fieldDef) return value;
+    const fieldType = fieldDef.type;
+    if (fieldType === "number") {
+      const num = Number(value);
+      return isNaN(num) ? value : num;
+    }
+    if (fieldType === "string") {
+      return String(value);
+    }
+    return value;
+  }
+  sort(a, b, orderBy) {
+    for (const order of orderBy) {
+      const fieldName = order.field;
+      const valA = this.coerceForComparison(a[fieldName], fieldName);
+      const valB = this.coerceForComparison(b[fieldName], fieldName);
+      if (valA === valB) continue;
+      const direction = order.direction === "asc" ? 1 : -1;
+      if (valA === null || valA === void 0)
+        return order.nulls === "first" ? -1 : 1;
+      if (valB === null || valB === void 0)
+        return order.nulls === "first" ? 1 : -1;
+      if (valA < valB) return -1 * direction;
+      if (valA > valB) return 1 * direction;
+    }
+    return 0;
+  }
+};
+
+// src/lock.ts
+import { throwLockTimeout } from "@datrix/core";
+import fs from "fs/promises";
+import path from "path";
+var SimpleLock = class {
+  lockPath;
+  lockTimeout;
+  // How long to wait to acquire lock
+  staleTimeout;
+  // How long a lock is valid
+  constructor(root, lockTimeout = 5e3, staleTimeout = 3e4) {
+    this.lockPath = path.join(root, "db.lock");
+    this.lockTimeout = lockTimeout;
+    this.staleTimeout = staleTimeout;
+  }
+  async acquire() {
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs.writeFile(this.lockPath, Date.now().toString(), {
+          flag: "wx"
+        });
+        return;
+      } catch (error) {
+        if (error.code !== "EEXIST") {
+          throw error;
+        }
+        const isStale = await this.checkStale();
+        if (isStale) {
+          try {
+            await fs.unlink(this.lockPath);
+            continue;
+          } catch (unlinkError) {
+          }
+        }
+        if (Date.now() - start > this.lockTimeout) {
+          throwLockTimeout({ adapter: "json", lockTimeout: this.lockTimeout });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    }
+  }
+  async release() {
+    try {
+      await fs.unlink(this.lockPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+      }
+    }
+  }
+  async checkStale() {
+    try {
+      const content = await fs.readFile(this.lockPath, "utf-8");
+      const timestamp = parseInt(content, 10);
+      if (isNaN(timestamp)) return true;
+      const age = Date.now() - timestamp;
+      return age > this.staleTimeout;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapter.ts
+import {
+  DatrixAdapterError as DatrixAdapterError2,
+  throwNotConnected,
+  throwConnectionError,
+  throwMigrationError as throwMigrationError2,
+  throwTransactionError,
+  throwQueryError,
+  throwMetaFieldAlreadyExists,
+  throwMetaFieldNotFound
+} from "@datrix/core";
+
+// src/transaction.ts
+import {
+  throwTransactionAlreadyCommitted,
+  throwTransactionAlreadyRolledBack,
+  throwTransactionSavepointNotSupported,
+  throwRawQueryNotSupported
+} from "@datrix/core";
+var JsonTransaction = class {
+  constructor(adapter, commitCallback, rollbackCallback) {
+    this.adapter = adapter;
+    this.commitCallback = commitCallback;
+    this.rollbackCallback = rollbackCallback;
+    this.id = `tx_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  }
+  id;
+  committed = false;
+  rolledBack = false;
+  /**
+   * Check if transaction is still active
+   */
+  assertActive() {
+    if (this.committed) {
+      throwTransactionAlreadyCommitted({ adapter: "json" });
+    }
+    if (this.rolledBack) {
+      throwTransactionAlreadyRolledBack({ adapter: "json" });
+    }
+  }
+  /**
+   * Execute query within transaction
+   *
+   * Uses adapter's executeQueryWithOptions with skipLock and skipWrite.
+   * Adapter automatically uses transaction cache.
+   */
+  async executeQuery(query) {
+    this.assertActive();
+    return this.adapter.executeQueryWithOptions(query, {
+      skipLock: true,
+      skipWrite: true
+    });
+  }
+  /**
+   * Execute raw SQL query (not supported for JSON adapter)
+   */
+  async executeRawQuery(_sql, _params) {
+    throwRawQueryNotSupported({ adapter: "json" });
+  }
+  // ========================================
+  // SchemaOperations implementation
+  // ========================================
+  /**
+   * Create table within transaction
+   */
+  async createTable(schema) {
+    this.assertActive();
+    return this.adapter.createTableWithOptions(schema, { skipWrite: true });
+  }
+  /**
+   * Drop table within transaction
+   */
+  async dropTable(tableName) {
+    this.assertActive();
+    return this.adapter.dropTableWithOptions(tableName, { skipWrite: true });
+  }
+  /**
+   * Rename table within transaction
+   */
+  async renameTable(from, to) {
+    this.assertActive();
+    return this.adapter.renameTableWithOptions(from, to, { skipWrite: true });
+  }
+  /**
+   * Alter table within transaction
+   */
+  async alterTable(tableName, operations) {
+    this.assertActive();
+    return this.adapter.alterTableWithOptions(tableName, operations, {
+      skipWrite: true
+    });
+  }
+  /**
+   * Add index within transaction
+   */
+  async addIndex(tableName, index) {
+    this.assertActive();
+    return this.adapter.addIndexWithOptions(tableName, index, {
+      skipWrite: true
+    });
+  }
+  /**
+   * Drop index within transaction
+   */
+  async dropIndex(tableName, indexName) {
+    this.assertActive();
+    return this.adapter.dropIndexWithOptions(tableName, indexName, {
+      skipWrite: true
+    });
+  }
+  /**
+   * Commit transaction
+   *
+   * Delegates to adapter's commitTransaction which writes to disk.
+   */
+  async commit() {
+    this.assertActive();
+    await this.commitCallback();
+    this.committed = true;
+  }
+  /**
+   * Rollback transaction
+   *
+   * Delegates to adapter's rollbackTransaction which discards changes.
+   */
+  async rollback() {
+    if (this.committed) {
+      throwTransactionAlreadyCommitted({ adapter: "json" });
+    }
+    if (this.rolledBack) {
+      return;
+    }
+    await this.rollbackCallback();
+    this.rolledBack = true;
+  }
+  /**
+   * Create savepoint (not yet implemented for JSON adapter)
+   */
+  async savepoint(_name) {
+    throwTransactionSavepointNotSupported({ adapter: "json" });
+  }
+  /**
+   * Rollback to savepoint (not yet implemented for JSON adapter)
+   */
+  async rollbackTo(_name) {
+    throwTransactionSavepointNotSupported({ adapter: "json" });
+  }
+  /**
+   * Release savepoint (not yet implemented for JSON adapter)
+   */
+  async release(_name) {
+    throwTransactionSavepointNotSupported({ adapter: "json" });
+  }
+};
+
+// src/adapter.ts
+import { FORJA_META_MODEL as FORJA_META_MODEL2, FORJA_META_KEY_PREFIX } from "@datrix/core";
+
+// src/table-utils.ts
+import {
+  DatrixAdapterError,
+  throwForeignKeyConstraint,
+  throwMigrationError,
+  throwUniqueConstraintField,
+  throwUniqueConstraintIndex
+} from "@datrix/core";
+import { FORJA_META_MODEL } from "@datrix/core";
+function validateTableName(tableName) {
+  if (tableName.includes("\0")) {
+    throwMigrationError({
+      adapter: "json",
+      message: "Invalid table name: contains null byte",
+      table: tableName
+    });
+  }
+  if (tableName.includes("/") || tableName.includes("\\")) {
+    throwMigrationError({
+      adapter: "json",
+      message: "Invalid table name: contains path separators",
+      table: tableName
+    });
+  }
+  if (tableName.includes("..")) {
+    throwMigrationError({
+      adapter: "json",
+      message: "Invalid table name: contains parent directory reference",
+      table: tableName
+    });
+  }
+}
+async function createMetaTable(adapter) {
+  const metaExists = await adapter.tableExists(FORJA_META_MODEL);
+  if (metaExists) {
+    return;
+  }
+  const metaSchema = {
+    name: FORJA_META_MODEL,
+    tableName: FORJA_META_MODEL,
+    fields: {
+      id: { type: "number", autoIncrement: true },
+      key: { type: "string", required: true, unique: true, maxLength: 255 },
+      value: { type: "string", required: true },
+      createdAt: { type: "date" },
+      updatedAt: { type: "date" }
+    }
+  };
+  await adapter.createTable(metaSchema);
+}
+function applyDefaultValues(schema, data) {
+  if (!schema?.fields) return;
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (fieldName in data) continue;
+    const defaultValue = fieldDef.default;
+    if (defaultValue !== void 0) {
+      data[fieldName] = defaultValue;
+    }
+  }
+}
+function checkUniqueConstraints(tableData, schema, newData, excludeId) {
+  if (!schema?.fields) return;
+  const existingData = tableData.data;
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (!fieldDef.unique) continue;
+    const value = newData[fieldName];
+    if (value === void 0 || value === null) continue;
+    const duplicate = existingData.find(
+      (row) => row[fieldName] === value && row["id"] !== excludeId
+    );
+    if (duplicate) {
+      throwUniqueConstraintField({
+        field: fieldName,
+        value,
+        adapter: "json",
+        table: schema.tableName ?? "unknown"
+      });
+    }
+  }
+  if (!schema.indexes) return;
+  for (const index of schema.indexes) {
+    if (!index.unique) continue;
+    const indexValues = index.fields.map((f) => newData[f]);
+    if (indexValues.some((v) => v === void 0 || v === null)) continue;
+    const duplicate = existingData.find(
+      (row) => index.fields.every((f) => row[f] === newData[f]) && row["id"] !== excludeId
+    );
+    if (duplicate) {
+      throwUniqueConstraintIndex({
+        fields: index.fields,
+        table: schema.tableName ?? "unknown",
+        adapter: "json"
+      });
+    }
+  }
+}
+async function checkForeignKeyConstraints(schema, data, adapter) {
+  if (!schema?.fields) return;
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (fieldDef.type !== "relation") continue;
+    const relationField = fieldDef;
+    if (relationField.kind !== "belongsTo" && relationField.kind !== "hasOne") {
+      continue;
+    }
+    const foreignKey = relationField.foreignKey ?? `${fieldName}Id`;
+    const fkValue = data[foreignKey];
+    if (fkValue === void 0 || fkValue === null) continue;
+    const targetSchema = await adapter.getSchemaByModelName(
+      relationField.model
+    );
+    if (!targetSchema) continue;
+    const targetTable = targetSchema.tableName ?? relationField.model.toLowerCase();
+    const targetData = await adapter.getCachedTable(targetTable);
+    if (!targetData) continue;
+    const exists = targetData.data.some((row) => row["id"] === fkValue);
+    if (!exists) {
+      throwForeignKeyConstraint({
+        foreignKey,
+        value: fkValue,
+        targetModel: relationField.model,
+        table: schema.tableName ?? "unknown",
+        adapter: "json"
+      });
+    }
+  }
+}
+async function findFkDependencies(targetTable, adapter) {
+  const allTables = await adapter.getTables();
+  const deps = [];
+  for (const tableName of allTables) {
+    const schema = await adapter.getSchemaByTableName(tableName);
+    if (!schema?.fields) continue;
+    for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+      if (fieldDef.type !== "number") continue;
+      const numField = fieldDef;
+      const ref = numField.references;
+      if (!ref || ref.table !== targetTable) continue;
+      const onDelete = ref.onDelete ?? "setNull";
+      deps.push({ tableName, fieldName, onDelete });
+    }
+  }
+  return deps;
+}
+async function applyOnDeleteActions(targetTable, idsToDelete, adapter, queryOptions) {
+  if (idsToDelete.length === 0) return;
+  const deps = await findFkDependencies(targetTable, adapter);
+  if (deps.length === 0) return;
+  for (const dep of deps) {
+    if (dep.onDelete !== "restrict") continue;
+    const tableData = await adapter.getCachedTable(dep.tableName);
+    if (!tableData) continue;
+    const hasReference = tableData.data.some(
+      (row) => idsToDelete.includes(row[dep.fieldName])
+    );
+    if (hasReference) {
+      throw new DatrixAdapterError(
+        `Cannot delete from '${targetTable}': referenced by '${dep.tableName}.${dep.fieldName}' with ON DELETE RESTRICT`,
+        {
+          adapter: "json",
+          code: "ADAPTER_FOREIGN_KEY_CONSTRAINT",
+          operation: "query",
+          context: {
+            table: targetTable,
+            referencedBy: `${dep.tableName}.${dep.fieldName}`
+          },
+          suggestion: `Remove or update referencing rows in '${dep.tableName}' before deleting from '${targetTable}'`
+        }
+      );
+    }
+  }
+  for (const dep of deps) {
+    if (dep.onDelete !== "setNull") continue;
+    await adapter.executeQueryWithOptions(
+      {
+        type: "update",
+        table: dep.tableName,
+        where: { [dep.fieldName]: { $in: idsToDelete } },
+        data: { [dep.fieldName]: null }
+      },
+      queryOptions
+    );
+  }
+  for (const dep of deps) {
+    if (dep.onDelete !== "cascade") continue;
+    const tableData = await adapter.getCachedTable(dep.tableName);
+    if (!tableData) continue;
+    const childIds = tableData.data.filter((row) => idsToDelete.includes(row[dep.fieldName])).map((row) => row["id"]);
+    if (childIds.length === 0) continue;
+    await applyOnDeleteActions(dep.tableName, childIds, adapter, queryOptions);
+    await adapter.executeQueryWithOptions(
+      {
+        type: "delete",
+        table: dep.tableName,
+        where: { id: { $in: childIds } }
+      },
+      queryOptions
+    );
+  }
+}
+function applySelectRecursive(rows, select, populate) {
+  if (!rows || rows.length === 0) {
+    return rows;
+  }
+  let result = rows;
+  if (select && select !== "*") {
+    const fieldsToKeep = new Set(select);
+    if (populate) {
+      for (const relationName of Object.keys(populate)) {
+        fieldsToKeep.add(relationName);
+      }
+    }
+    result = rows.map((row) => {
+      const projected = {};
+      for (const field of fieldsToKeep) {
+        if (field in row) {
+          projected[field] = row[field];
+        }
+      }
+      return projected;
+    });
+  }
+  if (populate) {
+    for (const [relationName, options] of Object.entries(populate)) {
+      if (typeof options === "boolean") continue;
+      const nestedSelect = options === "*" ? "*" : options.select;
+      const nestedPopulate = options === "*" ? void 0 : options.populate;
+      for (const row of result) {
+        const relationValue = row[relationName];
+        if (!relationValue) continue;
+        if (Array.isArray(relationValue)) {
+          row[relationName] = applySelectRecursive(
+            relationValue,
+            nestedSelect,
+            nestedPopulate
+          );
+        } else {
+          row[relationName] = applySelectRecursive(
+            [relationValue],
+            nestedSelect,
+            nestedPopulate
+          )[0];
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/export-import/exporter.ts
+var CHUNK_SIZE = 1e3;
+var JsonExporter = class {
+  constructor(root, adapter) {
+    this.root = root;
+    this.adapter = adapter;
+  }
+  async export(writer) {
+    await writer.writeMeta({
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const tables = await this.adapter.getTables();
+    for (const tableName of tables) {
+      const schema = await this.adapter.getTableSchema(tableName);
+      if (schema) {
+        await writer.writeSchema(schema);
+      }
+    }
+    for (const tableName of tables) {
+      await this.exportTable(tableName, writer);
+    }
+    await writer.finalize();
+  }
+  async exportTable(tableName, writer) {
+    const fs3 = await import("fs/promises");
+    const path3 = await import("path");
+    const filePath = path3.join(this.root, `${tableName}.json`);
+    const content = await fs3.readFile(filePath, "utf-8");
+    const tableFile = JSON.parse(content);
+    const rows = tableFile.data;
+    for (let i = 0; i < rows.length; i += CHUNK_SIZE) {
+      await writer.writeChunk(tableName, rows.slice(i, i + CHUNK_SIZE));
+    }
+    if (rows.length === 0) {
+      await writer.writeChunk(tableName, []);
+    }
+  }
+};
+
+// src/export-import/importer.ts
+var JsonImporter = class {
+  constructor(root, adapter) {
+    this.root = root;
+    this.adapter = adapter;
+  }
+  async import(reader) {
+    const schemas = await this.collectSchemas(reader);
+    const existingTables = await this.adapter.getTables();
+    for (const tableName of existingTables) {
+      await this.adapter.dropTableWithOptions(tableName, { isImport: true });
+    }
+    for (const schema of schemas.values()) {
+      await this.adapter.createTable(schema, { isImport: true });
+    }
+    const tables = await reader.getTables();
+    for (const tableName of tables) {
+      const rows = [];
+      for await (const chunk of reader.readChunks(tableName)) {
+        rows.push(...chunk);
+      }
+      await this.writeTableFile(tableName, rows);
+    }
+  }
+  async collectSchemas(reader) {
+    const schemas = /* @__PURE__ */ new Map();
+    for await (const schema of reader.readSchemas()) {
+      schemas.set(schema.tableName, schema);
+    }
+    return schemas;
+  }
+  async writeTableFile(tableName, rows) {
+    const fs3 = await import("fs/promises");
+    const path3 = await import("path");
+    const filePath = path3.join(this.root, `${tableName}.json`);
+    const maxId = rows.reduce((max, row) => {
+      const id = typeof row["id"] === "number" ? row["id"] : 0;
+      return id > max ? id : max;
+    }, 0);
+    const tableFile = {
+      meta: {
+        version: 1,
+        lastInsertId: maxId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: tableName
+      },
+      data: rows
+    };
+    await fs3.writeFile(filePath, JSON.stringify(tableFile, null, 2), "utf-8");
+  }
+};
+
+// src/populate.ts
+import {
+  throwSchemaNotFound,
+  throwRelationNotFound,
+  throwInvalidRelationType,
+  throwTargetModelNotFound
+} from "@datrix/core";
+var JsonPopulator = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async populate(rows, query) {
+    if (!query.populate || rows.length === 0) {
+      return rows;
+    }
+    const _currentSchema = await this.adapter.getSchemaByTableName(query.table);
+    if (!_currentSchema) {
+      throwSchemaNotFound({ adapter: "json", modelName: query.table });
+    }
+    const currentSchema = _currentSchema;
+    const currentModelName = currentSchema.name;
+    const result = [...rows];
+    for (const [relationName, _options] of Object.entries(query.populate)) {
+      const relationField = currentSchema.fields[relationName];
+      if (!relationField) {
+        throwRelationNotFound({
+          adapter: "json",
+          relationName,
+          schemaName: currentSchema.name
+        });
+      }
+      if (relationField.type !== "relation") {
+        throwInvalidRelationType({
+          adapter: "json",
+          relationName,
+          fieldType: relationField.type,
+          schemaName: currentSchema.name
+        });
+      }
+      const relField = relationField;
+      const targetModelName = relField.model;
+      const foreignKey = relField.foreignKey;
+      const kind = relField.kind;
+      const targetSchema = await this.adapter.getSchemaByModelName(targetModelName);
+      if (!targetSchema) {
+        throwTargetModelNotFound({
+          adapter: "json",
+          targetModel: targetModelName,
+          relationName,
+          schemaName: currentSchema.name
+        });
+      }
+      const targetTable = targetSchema.tableName ?? targetModelName.toLowerCase();
+      const tableData = await this.adapter.getCachedTable(targetTable);
+      if (!tableData) continue;
+      const relatedData = tableData.data;
+      const options = typeof _options === "object" && _options !== null && !Array.isArray(_options) ? _options : void 0;
+      if (kind === "belongsTo") {
+        const ids = new Set(
+          result.map((r) => r[foreignKey]).filter((id) => id !== null && id !== void 0)
+        );
+        const relatedMap = /* @__PURE__ */ new Map();
+        if (ids.size > 0) {
+          for (const item of relatedData) {
+            const itemId = item["id"];
+            if (ids.has(itemId)) {
+              relatedMap.set(itemId, item);
+            }
+          }
+        }
+        let filteredMap = relatedMap;
+        if (options?.where) {
+          filteredMap = /* @__PURE__ */ new Map();
+          const filterRunner = new JsonQueryRunner(
+            tableData,
+            this.adapter,
+            targetSchema
+          );
+          for (const [id, item] of relatedMap) {
+            const matched = await filterRunner.filterAndSort({
+              type: "select",
+              table: targetTable,
+              where: options.where,
+              select: "*"
+            });
+            if (matched.some((r) => r["id"] === id)) {
+              filteredMap.set(id, item);
+            }
+          }
+        }
+        for (const row of result) {
+          const fkValue = row[foreignKey];
+          if (fkValue !== null && fkValue !== void 0) {
+            row[relationName] = filteredMap.get(fkValue) ?? null;
+          } else {
+            row[relationName] = null;
+          }
+        }
+      } else if (kind === "hasMany" || kind === "hasOne") {
+        const sourceIds = new Set(
+          result.map((r) => r["id"]).filter((id) => id !== null && id !== void 0)
+        );
+        const grouped = /* @__PURE__ */ new Map();
+        for (const item of relatedData) {
+          const fkValue = item[foreignKey];
+          if (fkValue !== null && fkValue !== void 0 && sourceIds.has(fkValue)) {
+            const group = grouped.get(fkValue) ?? [];
+            group.push(item);
+            grouped.set(fkValue, group);
+          }
+        }
+        const hasSortOrFilter = options?.where || options?.orderBy || options?.limit !== void 0 || options?.offset !== void 0;
+        for (const row of result) {
+          const rowId = row["id"];
+          let group = grouped.get(rowId) ?? [];
+          if (kind === "hasOne") {
+            row[relationName] = group[0] ?? null;
+          } else {
+            if (hasSortOrFilter && group.length > 0) {
+              const groupTable = { ...tableData, data: group };
+              const groupRunner = new JsonQueryRunner(
+                groupTable,
+                this.adapter,
+                targetSchema
+              );
+              group = await groupRunner.filterAndSort({
+                type: "select",
+                table: targetTable,
+                where: options?.where,
+                orderBy: options?.orderBy,
+                limit: options?.limit,
+                offset: options?.offset,
+                select: "*"
+              });
+            }
+            row[relationName] = group;
+          }
+        }
+      } else if (kind === "manyToMany") {
+        const junctionTableName = relField.through;
+        const sourceFK = `${currentModelName}Id`;
+        const targetFK = `${targetModelName}Id`;
+        const junctionData = await this.adapter.getCachedTable(junctionTableName);
+        if (!junctionData) {
+          throw new Error(
+            `Junction table '${junctionTableName}' not found for manyToMany relation '${relationName}' in schema '${currentSchema.name}'`
+          );
+        }
+        const sourceIds = result.map((r) => r["id"]).filter((id) => id !== null && id !== void 0);
+        if (sourceIds.length === 0) continue;
+        const junctionRunner = new JsonQueryRunner(junctionData, this.adapter);
+        const relevantJunctions = await junctionRunner.run({
+          type: "select",
+          table: junctionTableName,
+          where: { [sourceFK]: { $in: sourceIds } },
+          select: "*"
+        });
+        const mapping = /* @__PURE__ */ new Map();
+        for (const junction of relevantJunctions) {
+          const srcId = junction[sourceFK];
+          const tgtId = junction[targetFK];
+          const normalizedSrcId = typeof srcId === "string" ? Number(srcId) : srcId;
+          const normalizedTgtId = typeof tgtId === "string" ? Number(tgtId) : tgtId;
+          const existing = mapping.get(normalizedSrcId) ?? [];
+          existing.push(normalizedTgtId);
+          mapping.set(normalizedSrcId, existing);
+        }
+        const allTargetIds = /* @__PURE__ */ new Set();
+        for (const ids of mapping.values()) {
+          ids.forEach((id) => allTargetIds.add(id));
+        }
+        const targetDataForRunner = await this.adapter.getCachedTable(targetTable);
+        if (!targetDataForRunner) continue;
+        const idFilter = { id: { $in: Array.from(allTargetIds) } };
+        const userWhere = options?.where;
+        const mergedWhere = userWhere ? { $and: [idFilter, userWhere] } : idFilter;
+        const targetRunner = new JsonQueryRunner(
+          targetDataForRunner,
+          this.adapter,
+          targetSchema
+        );
+        const targetRecords = await targetRunner.run({
+          type: "select",
+          table: targetTable,
+          where: mergedWhere,
+          orderBy: options?.orderBy,
+          select: "*"
+        });
+        for (const row of result) {
+          const rowId = row["id"];
+          const normalizedRowId = typeof rowId === "string" ? Number(rowId) : rowId;
+          const targetIds = mapping.get(normalizedRowId) ?? [];
+          let relatedRecords = targetRecords.filter((r) => {
+            const rID = r["id"];
+            const normalizedRID = typeof rID === "string" ? Number(rID) : rID;
+            return targetIds.includes(normalizedRID);
+          });
+          const offset = options?.offset ?? 0;
+          if (options?.limit !== void 0) {
+            relatedRecords = relatedRecords.slice(
+              offset,
+              offset + options.limit
+            );
+          } else if (offset > 0) {
+            relatedRecords = relatedRecords.slice(offset);
+          }
+          row[relationName] = relatedRecords;
+        }
+      }
+      if (typeof _options === "object" && _options !== null && _options.populate) {
+        const nextRows = [];
+        for (const row of result) {
+          const val = row[relationName];
+          if (!val) continue;
+          if (Array.isArray(val)) {
+            nextRows.push(...val);
+          } else {
+            nextRows.push(val);
+          }
+        }
+        if (nextRows.length > 0) {
+          await this.populate(nextRows, {
+            type: "select",
+            table: targetTable,
+            populate: _options.populate,
+            select: "*"
+          });
+        }
+      }
+    }
+    return result;
+  }
+};
+
+// src/query-handlers.ts
+import { throwQueryMissingData } from "@datrix/core";
+async function handleSelect(ctx) {
+  const { runner, query, adapter } = ctx;
+  let rows;
+  if (query.populate) {
+    rows = await runner.filterAndSort(query);
+    const populator = new JsonPopulator(adapter);
+    rows = await populator.populate(rows, query);
+    rows = applySelectRecursive(rows, query.select, query.populate);
+  } else {
+    rows = await runner.run(query);
+  }
+  return {
+    rows,
+    metadata: { rowCount: rows.length, affectedRows: 0 },
+    shouldWrite: false
+  };
+}
+async function handleCount(ctx) {
+  const { runner, query } = ctx;
+  const rows = await runner.run(query);
+  return {
+    rows: [],
+    metadata: { rowCount: 0, affectedRows: 0, count: rows.length },
+    shouldWrite: false,
+    earlyReturn: true
+  };
+}
+async function handleInsert(ctx) {
+  const { runner, query } = ctx;
+  const tableData = runner.tableData;
+  const tableSchema = runner.tableSchema;
+  const adapter = runner.adapterRef;
+  if (!query.data || !Array.isArray(query.data)) {
+    throwQueryMissingData({
+      queryType: "insert",
+      table: query.table,
+      adapter: "json"
+    });
+  }
+  const insertedIds = [];
+  const isJunctionTable = tableSchema?._isJunctionTable === true;
+  for (const item of query.data) {
+    const newItem = { ...item };
+    if (isJunctionTable) {
+      const alreadyExists = tableData.data.some(
+        (row) => Object.keys(newItem).every(
+          (key) => key === "id" || row[key] === newItem[key]
+        )
+      );
+      if (alreadyExists) continue;
+    }
+    if (!newItem["id"]) {
+      tableData.meta.lastInsertId = (tableData.meta.lastInsertId ?? 0) + 1;
+      newItem["id"] = tableData.meta.lastInsertId;
+    } else {
+      const manualId = Number(newItem["id"]);
+      if (!isNaN(manualId) && manualId > (tableData.meta.lastInsertId ?? 0)) {
+        tableData.meta.lastInsertId = manualId;
+      }
+    }
+    applyDefaultValues(tableSchema, newItem);
+    await checkForeignKeyConstraints(tableSchema, newItem, adapter);
+    checkUniqueConstraints(tableData, tableSchema, newItem);
+    tableData.data.push(newItem);
+    insertedIds.push(newItem["id"]);
+  }
+  const rows = insertedIds.map((id) => ({ id }));
+  return {
+    rows,
+    metadata: {
+      rowCount: insertedIds.length,
+      affectedRows: insertedIds.length,
+      insertIds: insertedIds
+    },
+    shouldWrite: true
+  };
+}
+async function handleUpdate(ctx) {
+  const { runner, query } = ctx;
+  const tableData = runner.tableData;
+  const tableSchema = runner.tableSchema;
+  const adapter = runner.adapterRef;
+  if (!query.data) {
+    throwQueryMissingData({
+      queryType: "update",
+      table: query.table,
+      adapter: "json"
+    });
+  }
+  const updateQuery = {
+    ...query,
+    limit: void 0,
+    offset: void 0,
+    orderBy: void 0
+  };
+  const rowsToUpdate = await runner.filterAndSort(updateQuery);
+  for (const row of rowsToUpdate) {
+    const updatedData = { ...row, ...query.data };
+    await checkForeignKeyConstraints(tableSchema, updatedData, adapter);
+    checkUniqueConstraints(
+      tableData,
+      tableSchema,
+      updatedData,
+      row["id"]
+    );
+  }
+  for (const row of rowsToUpdate) {
+    Object.assign(row, query.data);
+  }
+  const updatedIds = rowsToUpdate.map((r) => r["id"]);
+  const rows = updatedIds.map((id) => ({ id }));
+  return {
+    rows,
+    metadata: { rowCount: updatedIds.length, affectedRows: updatedIds.length },
+    shouldWrite: true
+  };
+}
+async function handleDelete(ctx) {
+  const { runner, query, adapter, queryOptions } = ctx;
+  const tableData = runner.tableData;
+  const deleteQuery = {
+    ...query,
+    limit: void 0,
+    offset: void 0,
+    orderBy: void 0
+  };
+  const rowsToDelete = await runner.filterAndSort(deleteQuery);
+  const idsToDelete = rowsToDelete.map((r) => r.id);
+  await applyOnDeleteActions(query.table, idsToDelete, adapter, queryOptions);
+  const idsSet = new Set(idsToDelete);
+  const originalLength = tableData.data.length;
+  tableData.data = tableData.data.filter((d) => !idsSet.has(d["id"]));
+  const deletedIds = rowsToDelete.map((r) => r["id"]);
+  const rows = deletedIds.map((id) => ({ id }));
+  return {
+    rows,
+    metadata: {
+      rowCount: deletedIds.length,
+      affectedRows: originalLength - tableData.data.length
+    },
+    shouldWrite: true
+  };
+}
+
+// src/adapter.ts
+var JsonAdapter = class {
+  name = "json";
+  config;
+  state = "disconnected";
+  cache = /* @__PURE__ */ new Map();
+  lock;
+  cacheEnabled;
+  readLockEnabled;
+  /**
+   * Active transaction cache reference
+   * When a transaction is active, all reads/writes go through this cache first.
+   * Set by beginTransaction, cleared by commit/rollback.
+   */
+  activeTransactionCache = null;
+  /**
+   * Track modified tables during transaction for commit
+   */
+  activeTransactionModifiedTables = null;
+  /**
+   * Tombstone set for tables deleted during transaction.
+   * Prevents fallback to main cache or disk for dropped tables.
+   */
+  activeTransactionDeletedTables = null;
+  constructor(config) {
+    this.config = config;
+    this.lock = new SimpleLock(
+      config.root,
+      config.lockTimeout,
+      config.staleTimeout
+    );
+    this.cacheEnabled = config.cache !== false;
+    this.readLockEnabled = config.readLock === true;
+  }
+  /**
+   * Connect involves ensuring the root directory exists
+   */
+  async connect() {
+    if (this.state === "connected") {
+      return;
+    }
+    this.state = "connecting";
+    try {
+      await fs2.mkdir(this.config.root, { recursive: true });
+      this.state = "connected";
+      if (this.config.standalone) {
+        try {
+          await createMetaTable(this);
+        } catch (error) {
+          this.state = "error";
+          throw error;
+        }
+      }
+    } catch (error) {
+      this.state = "error";
+      const message = error instanceof Error ? error.message : String(error);
+      throwConnectionError({
+        adapter: "json",
+        message: `Failed to access root directory: ${message}`,
+        cause: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+  async disconnect() {
+    this.state = "disconnected";
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getConnectionState() {
+    return this.state;
+  }
+  /**
+   * Helper to get file path for a table
+   */
+  getTablePath(tableName) {
+    return path2.join(this.config.root, `${tableName}.json`);
+  }
+  /**
+   * Read table with cache support
+   *
+   * Cache lookup order:
+   * 1. Check tombstone (if transaction active and table was dropped)
+   * 2. Transaction cache (if active)
+   * 3. Main cache (with mtime validation)
+   * 4. Disk
+   *
+   * When transaction is active, new reads are cached in transaction cache.
+   * This ensures isolation - transaction sees its own writes.
+   */
+  async readTable(tableName) {
+    const filePath = this.getTablePath(tableName);
+    if (this.activeTransactionDeletedTables?.has(tableName)) {
+      throw new Error(`Table '${tableName}' does not exist`);
+    }
+    if (this.activeTransactionCache) {
+      const txCached = this.activeTransactionCache.get(tableName);
+      if (txCached) {
+        return txCached.data;
+      }
+    }
+    if (this.cacheEnabled) {
+      const stat = await fs2.stat(filePath);
+      const mtime = stat.mtimeMs;
+      const cached = this.cache.get(tableName);
+      if (cached && cached.mtime === mtime) {
+        if (this.activeTransactionCache) {
+          const txData = JSON.parse(JSON.stringify(cached.data));
+          this.activeTransactionCache.set(tableName, { data: txData, mtime });
+          return txData;
+        }
+        return cached.data;
+      }
+      const content2 = await fs2.readFile(filePath, "utf-8");
+      const data = JSON.parse(content2);
+      if (this.activeTransactionCache) {
+        this.activeTransactionCache.set(tableName, { data, mtime });
+      } else {
+        this.cache.set(tableName, { data, mtime });
+      }
+      return data;
+    }
+    const content = await fs2.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * Get cached table data (for external use like Populate)
+   */
+  async getCachedTable(tableName) {
+    try {
+      return await this.readTable(tableName);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get schema directly from table file (cache-aware)
+   * This is faster than going through Datrix registry and ensures consistency
+   *
+   * @param tableName - Table name (e.g., "users")
+   * @returns Schema definition or null if not found
+   */
+  async getSchemaByTableName(tableName) {
+    try {
+      return await this.readTableSchema(tableName);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get schema by model name
+   * Requires scanning all tables to find matching schema.name
+   * Prefer getSchemaByTableName when table name is known (faster)
+   *
+   * @param modelName - Model name from schema (e.g., "User")
+   * @returns Schema definition or null if not found
+   */
+  async getSchemaByModelName(modelName) {
+    try {
+      const tablesResult = await this.getTables();
+      for (const tableName of tablesResult) {
+        const schema = await this.getSchemaByTableName(tableName);
+        if (schema?.name === modelName) {
+          return schema;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Find table name by schema model name
+   *
+   * @param modelName - Model name (e.g., "User")
+   * @returns Table name or null if not found
+   */
+  async findTableNameByModelName(modelName) {
+    const schema = await this.getSchemaByModelName(modelName);
+    return schema?.tableName ?? null;
+  }
+  /**
+   * Read schema for a table from _datrix metadata table.
+   * Transaction-aware: reads from tx cache when inside a transaction.
+   *
+   * @param tableName - Physical table name (e.g. "users")
+   */
+  async readTableSchema(tableName) {
+    const metaFile = await this.readTable(FORJA_META_MODEL2);
+    const metaKey = `${FORJA_META_KEY_PREFIX}${tableName}`;
+    const row = metaFile.data.find(
+      (r) => r["key"] === metaKey
+    );
+    if (!row) {
+      throw new Error(`Schema for '${tableName}' not found in _datrix`);
+    }
+    return JSON.parse(
+      row["value"]
+    );
+  }
+  /**
+   * Upsert schema into _datrix metadata table
+   */
+  async upsertSchemaMeta(schema, skipWrite) {
+    const metaKey = `${FORJA_META_KEY_PREFIX}${schema.tableName ?? schema.name}`;
+    const metaValue = JSON.stringify(schema);
+    const metaFile = await this.readTable(FORJA_META_MODEL2);
+    const existingIndex = metaFile.data.findIndex(
+      (r) => r["key"] === metaKey
+    );
+    if (existingIndex >= 0) {
+      metaFile.data[existingIndex]["value"] = metaValue;
+    } else {
+      const lastInsertId = (metaFile.meta.lastInsertId ?? 0) + 1;
+      metaFile.meta.lastInsertId = lastInsertId;
+      metaFile.data.push({
+        id: lastInsertId,
+        key: metaKey,
+        value: metaValue
+      });
+    }
+    metaFile.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (skipWrite) {
+      this.activeTransactionCache.set(FORJA_META_MODEL2, {
+        data: metaFile,
+        mtime: Date.now()
+      });
+      this.activeTransactionModifiedTables.add(FORJA_META_MODEL2);
+    } else {
+      const filePath = this.getTablePath(FORJA_META_MODEL2);
+      await fs2.writeFile(filePath, JSON.stringify(metaFile, null, 2), "utf-8");
+      await this.updateCache(FORJA_META_MODEL2, metaFile);
+    }
+  }
+  /**
+   * Apply AlterOperations to schema in _datrix and write back
+   */
+  async applyOperationsToMetaSchema(tableName, operations, skipWrite) {
+    const schema = await this.readTableSchema(tableName);
+    const fields = { ...schema.fields };
+    for (const op of operations) {
+      switch (op.type) {
+        case "addColumn":
+          fields[op.column] = op.definition;
+          break;
+        case "dropColumn":
+          delete fields[op.column];
+          break;
+        case "modifyColumn":
+          fields[op.column] = op.newDefinition;
+          break;
+        case "renameColumn": {
+          const fieldDef = fields[op.from];
+          if (fieldDef !== void 0) {
+            fields[op.to] = fieldDef;
+            delete fields[op.from];
+          }
+          for (const [key, def] of Object.entries(fields)) {
+            if (def.type === "relation" && def.foreignKey === op.from) {
+              fields[key] = { ...def, foreignKey: op.to };
+            }
+          }
+          break;
+        }
+        case "addMetaField":
+          if (fields[op.field] !== void 0) {
+            throwMetaFieldAlreadyExists({
+              adapter: "json",
+              field: op.field,
+              table: tableName
+            });
+          }
+          fields[op.field] = op.definition;
+          break;
+        case "dropMetaField":
+          if (fields[op.field] === void 0) {
+            throwMetaFieldNotFound({
+              adapter: "json",
+              field: op.field,
+              table: tableName
+            });
+          }
+          delete fields[op.field];
+          break;
+        case "modifyMetaField":
+          if (fields[op.field] === void 0) {
+            throwMetaFieldNotFound({
+              adapter: "json",
+              field: op.field,
+              table: tableName
+            });
+          }
+          fields[op.field] = op.newDefinition;
+          break;
+      }
+    }
+    const updatedSchema = { ...schema, fields };
+    await this.upsertSchemaMeta(updatedSchema, skipWrite);
+  }
+  /**
+   * Invalidate cache for a specific table
+   */
+  invalidateCache(tableName) {
+    this.cache.delete(tableName);
+  }
+  /**
+   * Update cache after write operation
+   */
+  async updateCache(tableName, data) {
+    if (!this.cacheEnabled) return;
+    const filePath = this.getTablePath(tableName);
+    try {
+      const stat = await fs2.stat(filePath);
+      this.cache.set(tableName, { data, mtime: stat.mtimeMs });
+    } catch {
+      this.invalidateCache(tableName);
+    }
+  }
+  async exportData(writer) {
+    await new JsonExporter(this.config.root, this).export(writer);
+  }
+  async importData(reader) {
+    await new JsonImporter(this.config.root, this).import(reader);
+  }
+  async createTable(schema, options) {
+    return this.createTableWithOptions(schema, void 0, options?.isImport);
+  }
+  /**
+   * Create table with options (for transaction support)
+   */
+  async createTableWithOptions(schema, options, isImport) {
+    const skipWrite = options?.skipWrite ?? false;
+    if (this.config.standalone && !("id" in schema.fields)) {
+      schema = {
+        ...schema,
+        fields: {
+          id: { type: "number", autoIncrement: true },
+          ...schema.fields
+        }
+      };
+    }
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    const tableName = schema.tableName;
+    validateTableName(tableName);
+    if (this.activeTransactionCache?.has(tableName)) {
+      throwMigrationError2({
+        adapter: "json",
+        message: `Table '${schema.name}' already exists`,
+        table: tableName
+      });
+    }
+    const wasDeleted = this.activeTransactionDeletedTables?.has(tableName);
+    if (wasDeleted) {
+      this.activeTransactionDeletedTables.delete(tableName);
+    }
+    if (!wasDeleted) {
+      const filePath = this.getTablePath(tableName);
+      try {
+        await fs2.access(filePath);
+        throwMigrationError2({
+          adapter: "json",
+          message: `Table '${schema.name}' already exists`
+        });
+      } catch (err) {
+        if (err instanceof DatrixAdapterError2) throw err;
+      }
+    }
+    const initialContent = {
+      meta: {
+        version: 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: schema.name
+      },
+      data: []
+    };
+    if (skipWrite) {
+      this.activeTransactionCache.set(tableName, {
+        data: initialContent,
+        mtime: Date.now()
+      });
+      this.activeTransactionModifiedTables.add(tableName);
+    } else {
+      const filePath = this.getTablePath(tableName);
+      await fs2.writeFile(
+        filePath,
+        JSON.stringify(initialContent, null, 2),
+        "utf-8"
+      );
+      await this.updateCache(tableName, initialContent);
+    }
+    if (!isImport) {
+      if (schema.name !== FORJA_META_MODEL2) {
+        const metaExists = await this.tableExists(FORJA_META_MODEL2);
+        if (!metaExists) {
+          throwMigrationError2({
+            adapter: "json",
+            message: `Cannot create table '${schema.name}': '${FORJA_META_MODEL2}' table does not exist yet. Create '${FORJA_META_MODEL2}' first.`
+          });
+        }
+      }
+      await this.upsertSchemaMeta(schema, skipWrite);
+    }
+  }
+  async dropTable(tableName) {
+    return this.dropTableWithOptions(tableName);
+  }
+  /**
+   * Drop table with options (for transaction support)
+   */
+  async dropTableWithOptions(tableName, options) {
+    const skipWrite = options?.skipWrite ?? false;
+    const isImport = options?.isImport ?? false;
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    if (this.activeTransactionDeletedTables?.has(tableName)) {
+      throwMigrationError2({
+        adapter: "json",
+        message: `Table '${tableName}' does not exist`
+      });
+    }
+    const existsInTxCache = this.activeTransactionCache?.has(tableName);
+    const existsInMainCache = this.cache.has(tableName);
+    let existsOnDisk = false;
+    if (!existsInTxCache && !existsInMainCache) {
+      const filePath = this.getTablePath(tableName);
+      try {
+        await fs2.access(filePath);
+        existsOnDisk = true;
+      } catch {
+      }
+    }
+    if (!existsInTxCache && !existsInMainCache && !existsOnDisk) {
+      throwMigrationError2({
+        adapter: "json",
+        message: `Table '${tableName}' does not exist`
+      });
+    }
+    if (skipWrite) {
+      this.activeTransactionDeletedTables.add(tableName);
+      this.activeTransactionCache.delete(tableName);
+    } else {
+      const filePath = this.getTablePath(tableName);
+      await fs2.unlink(filePath);
+      this.invalidateCache(tableName);
+    }
+    if (!isImport && tableName !== FORJA_META_MODEL2) {
+      const metaKey = `${FORJA_META_KEY_PREFIX}${tableName}`;
+      const metaFile = await this.readTable(FORJA_META_MODEL2);
+      metaFile.data = metaFile.data.filter(
+        (r) => r["key"] !== metaKey
+      );
+      metaFile.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (skipWrite) {
+        this.activeTransactionCache.set(FORJA_META_MODEL2, {
+          data: metaFile,
+          mtime: Date.now()
+        });
+        this.activeTransactionModifiedTables.add(FORJA_META_MODEL2);
+      } else {
+        const filePath = this.getTablePath(FORJA_META_MODEL2);
+        await fs2.writeFile(
+          filePath,
+          JSON.stringify(metaFile, null, 2),
+          "utf-8"
+        );
+        await this.updateCache(FORJA_META_MODEL2, metaFile);
+      }
+    }
+  }
+  /**
+   * Execute query (public interface)
+   *
+   * This is the standard DatabaseAdapter interface method.
+   * Internally calls executeQueryWithOptions with default options.
+   */
+  async executeQuery(query) {
+    return this.executeQueryWithOptions(query);
+  }
+  /**
+   * Execute query with options (for transaction support)
+   *
+   * @param query - Query to execute
+   * @param options - Execution options
+   * @param options.skipLock - Skip lock acquisition (transaction already holds lock)
+   * @param options.skipWrite - Skip writing to disk (transaction will write on commit)
+   */
+  async executeQueryWithOptions(query, options) {
+    const skipLock = options?.skipLock ?? false;
+    const skipWrite = options?.skipWrite ?? false;
+    validateQueryObject(query);
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    const isWriteOp = ["insert", "update", "delete"].includes(query.type);
+    const needsLock = !skipLock && (isWriteOp || this.readLockEnabled);
+    let lockAcquired = false;
+    if (needsLock) {
+      try {
+        await this.lock.acquire();
+        lockAcquired = true;
+      } catch (err) {
+        throwQueryError({
+          adapter: "json",
+          message: `Failed to acquire lock: ${err instanceof Error ? err.message : String(err)}`,
+          query,
+          cause: err instanceof Error ? err : new Error(String(err))
+        });
+      }
+    }
+    try {
+      let tableData;
+      try {
+        tableData = await this.readTable(query.table);
+      } catch (err) {
+        if (lockAcquired) await this.lock.release();
+        throwQueryError({
+          adapter: "json",
+          message: `Table '${query.table}' not found`,
+          query,
+          cause: err instanceof Error ? err : new Error(String(err))
+        });
+      }
+      if (!tableData.data || !Array.isArray(tableData.data)) {
+        tableData.data = [];
+      }
+      let tableSchema;
+      try {
+        tableSchema = await this.readTableSchema(query.table);
+      } catch {
+      }
+      const runner = new JsonQueryRunner(tableData, this, tableSchema);
+      let handlerResult;
+      switch (query.type) {
+        case "count":
+          handlerResult = await handleCount({ runner, query });
+          if (handlerResult.earlyReturn) {
+            if (lockAcquired) await this.lock.release();
+            return {
+              rows: [],
+              metadata: handlerResult.metadata
+            };
+          }
+          break;
+        case "select":
+          handlerResult = await handleSelect({ runner, query, adapter: this });
+          break;
+        case "insert":
+          handlerResult = await handleInsert({ runner, query });
+          break;
+        case "update":
+          handlerResult = await handleUpdate({ runner, query });
+          break;
+        case "delete":
+          handlerResult = await handleDelete({
+            runner,
+            query,
+            adapter: this,
+            queryOptions: { skipLock: true, skipWrite }
+          });
+          break;
+      }
+      const rows = handlerResult.rows;
+      const metadata = handlerResult.metadata;
+      const shouldWrite = handlerResult.shouldWrite;
+      if (shouldWrite) {
+        if (skipWrite) {
+          if (this.activeTransactionModifiedTables) {
+            this.activeTransactionModifiedTables.add(query.table);
+          }
+        } else {
+          tableData.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const filePath = this.getTablePath(query.table);
+          await fs2.writeFile(
+            filePath,
+            JSON.stringify(tableData, null, 2),
+            "utf-8"
+          );
+          await this.updateCache(query.table, tableData);
+        }
+      }
+      metadata.rowCount = rows.length;
+      if (lockAcquired) await this.lock.release();
+      return {
+        rows,
+        metadata
+      };
+    } catch (error) {
+      if (lockAcquired) await this.lock.release();
+      throw error;
+    }
+  }
+  async executeRawQuery(_sql, _params) {
+    throwQueryError({
+      adapter: "json",
+      message: "executeRawQuery is not supported by JsonAdapter"
+    });
+  }
+  /**
+   * Begin a new transaction
+   *
+   * Acquires lock and creates isolated transaction cache.
+   * All reads/writes within transaction use txCache.
+   */
+  async beginTransaction() {
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    if (this.activeTransactionCache) {
+      throwTransactionError({
+        adapter: "json",
+        message: "A transaction is already active"
+      });
+    }
+    try {
+      await this.lock.acquire();
+      this.activeTransactionCache = /* @__PURE__ */ new Map();
+      this.activeTransactionModifiedTables = /* @__PURE__ */ new Set();
+      this.activeTransactionDeletedTables = /* @__PURE__ */ new Set();
+      const transaction = new JsonTransaction(
+        this,
+        // Commit callback
+        async () => {
+          await this.commitTransaction();
+        },
+        // Rollback callback
+        async () => {
+          await this.rollbackTransaction();
+        }
+      );
+      return transaction;
+    } catch (err) {
+      throwTransactionError({
+        adapter: "json",
+        message: `Failed to begin transaction: ${err instanceof Error ? err.message : String(err)}`,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  /**
+   * Commit transaction - write modified tables to disk
+   * @internal Called by JsonTransaction.commit()
+   */
+  async commitTransaction() {
+    if (!this.activeTransactionCache || !this.activeTransactionModifiedTables) {
+      throwTransactionError({
+        adapter: "json",
+        message: "No active transaction to commit"
+      });
+    }
+    try {
+      if (this.activeTransactionDeletedTables) {
+        for (const tableName of this.activeTransactionDeletedTables) {
+          const filePath = this.getTablePath(tableName);
+          try {
+            await fs2.unlink(filePath);
+          } catch {
+          }
+          this.cache.delete(tableName);
+        }
+      }
+      for (const tableName of this.activeTransactionModifiedTables) {
+        if (this.activeTransactionDeletedTables?.has(tableName)) continue;
+        const entry = this.activeTransactionCache.get(tableName);
+        if (entry) {
+          entry.data.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const filePath = this.getTablePath(tableName);
+          await fs2.writeFile(
+            filePath,
+            JSON.stringify(entry.data, null, 2),
+            "utf-8"
+          );
+          const stat = await fs2.stat(filePath);
+          entry.mtime = stat.mtimeMs;
+          this.cache.set(tableName, entry);
+        }
+      }
+    } finally {
+      this.activeTransactionCache = null;
+      this.activeTransactionModifiedTables = null;
+      this.activeTransactionDeletedTables = null;
+      await this.lock.release();
+    }
+  }
+  /**
+   * Rollback transaction - discard changes
+   * @internal Called by JsonTransaction.rollback()
+   */
+  async rollbackTransaction() {
+    this.activeTransactionCache = null;
+    this.activeTransactionModifiedTables = null;
+    this.activeTransactionDeletedTables = null;
+    await this.lock.release();
+  }
+  async alterTable(tableName, operations) {
+    return this.alterTableWithOptions(tableName, operations);
+  }
+  /**
+   * Alter table with options (for transaction support)
+   */
+  async alterTableWithOptions(tableName, operations, options) {
+    const skipWrite = options?.skipWrite ?? false;
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    const json = await this.readTable(tableName);
+    for (const op of operations) {
+      switch (op.type) {
+        case "addColumn": {
+          const defaultValue = op.definition.default;
+          for (const row of json.data) {
+            if (!(op.column in row)) {
+              row[op.column] = defaultValue ?? null;
+            }
+          }
+          break;
+        }
+        case "dropColumn": {
+          for (const row of json.data) {
+            delete row[op.column];
+          }
+          break;
+        }
+        case "modifyColumn": {
+          break;
+        }
+        case "renameColumn": {
+          for (const row of json.data) {
+            const r = row;
+            if (op.from in r) {
+              r[op.to] = r[op.from];
+              delete r[op.from];
+            }
+          }
+          break;
+        }
+      }
+    }
+    json.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (skipWrite) {
+      this.activeTransactionCache.set(tableName, {
+        data: json,
+        mtime: Date.now()
+      });
+      this.activeTransactionModifiedTables.add(tableName);
+    } else {
+      const filePath = this.getTablePath(tableName);
+      await fs2.writeFile(filePath, JSON.stringify(json, null, 2), "utf-8");
+      await this.updateCache(tableName, json);
+    }
+    if (tableName !== FORJA_META_MODEL2) {
+      await this.applyOperationsToMetaSchema(tableName, operations, skipWrite);
+    }
+  }
+  async renameTable(from, to) {
+    return this.renameTableWithOptions(from, to);
+  }
+  /**
+   * Rename table with options (for transaction support)
+   */
+  async renameTableWithOptions(from, to, options) {
+    const skipWrite = options?.skipWrite ?? false;
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    validateTableName(to);
+    if (this.activeTransactionDeletedTables?.has(from)) {
+      throwMigrationError2({
+        adapter: "json",
+        message: `Table '${from}' does not exist`
+      });
+    }
+    const targetExistsInTxCache = this.activeTransactionCache?.has(to);
+    const targetExistsInMainCache = this.cache.has(to);
+    let targetExistsOnDisk = false;
+    if (!targetExistsInTxCache && !targetExistsInMainCache) {
+      const toPath = this.getTablePath(to);
+      try {
+        await fs2.access(toPath);
+        targetExistsOnDisk = true;
+      } catch {
+      }
+    }
+    const targetInTombstone = this.activeTransactionDeletedTables?.has(to);
+    if ((targetExistsInTxCache || targetExistsInMainCache || targetExistsOnDisk) && !targetInTombstone) {
+      throwMigrationError2({
+        adapter: "json",
+        message: `Table '${to}' already exists`
+      });
+    }
+    const json = await this.readTable(from);
+    json.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (skipWrite) {
+      this.activeTransactionCache.set(to, {
+        data: json,
+        mtime: Date.now()
+      });
+      this.activeTransactionModifiedTables.add(to);
+      this.activeTransactionDeletedTables.add(from);
+      this.activeTransactionCache.delete(from);
+      this.activeTransactionDeletedTables.delete(to);
+    } else {
+      const fromPath = this.getTablePath(from);
+      const toPath = this.getTablePath(to);
+      await fs2.writeFile(toPath, JSON.stringify(json, null, 2), "utf-8");
+      await fs2.unlink(fromPath);
+      this.invalidateCache(from);
+      await this.updateCache(to, json);
+    }
+    if (from !== FORJA_META_MODEL2 && to !== FORJA_META_MODEL2) {
+      const oldKey = `${FORJA_META_KEY_PREFIX}${from}`;
+      const newKey = `${FORJA_META_KEY_PREFIX}${to}`;
+      const metaFile = await this.readTable(FORJA_META_MODEL2);
+      const row = metaFile.data.find(
+        (r) => r["key"] === oldKey
+      );
+      if (row) {
+        row["key"] = newKey;
+        metaFile.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (skipWrite) {
+          this.activeTransactionCache.set(FORJA_META_MODEL2, {
+            data: metaFile,
+            mtime: Date.now()
+          });
+          this.activeTransactionModifiedTables.add(FORJA_META_MODEL2);
+        } else {
+          const metaPath = this.getTablePath(FORJA_META_MODEL2);
+          await fs2.writeFile(
+            metaPath,
+            JSON.stringify(metaFile, null, 2),
+            "utf-8"
+          );
+          await this.updateCache(FORJA_META_MODEL2, metaFile);
+        }
+      }
+    }
+  }
+  async addIndex(tableName, index) {
+    return this.addIndexWithOptions(tableName, index);
+  }
+  /**
+   * Add index with options (for transaction support)
+   * Note: JSON adapter doesn't actually create indexes, but we track the operation
+   */
+  async addIndexWithOptions(_tableName, _index, _options) {
+  }
+  async dropIndex(tableName, indexName) {
+    return this.dropIndexWithOptions(tableName, indexName);
+  }
+  /**
+   * Drop index with options (for transaction support)
+   * Note: JSON adapter doesn't actually manage indexes, but we track the operation
+   */
+  async dropIndexWithOptions(_tableName, _indexName, _options) {
+  }
+  async getTables() {
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    const files = await fs2.readdir(this.config.root);
+    const tables = files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+    return tables;
+  }
+  async getTableSchema(tableName) {
+    if (!this.isConnected()) {
+      throwNotConnected({ adapter: "json" });
+    }
+    try {
+      const schema = await this.readTableSchema(tableName);
+      return schema;
+    } catch {
+      return null;
+    }
+  }
+  async tableExists(tableName) {
+    if (!this.isConnected()) return false;
+    try {
+      await fs2.access(this.getTablePath(tableName));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+export {
+  JsonAdapter
+};
+//# sourceMappingURL=index.mjs.map