@framers/sql-storage-adapter 0.7.2 → 0.7.3

package/dist/cjs/features/kv/valueCodec.js

@@ -0,0 +1,426 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var valueCodec_exports = {};
+__export(valueCodec_exports, {
+  decodeValue: () => decodeValue,
+  encodeValue: () => encodeValue
+});
+module.exports = __toCommonJS(valueCodec_exports);
+const FORMAT = 1;
+const ERROR_CONSTRUCTORS = {
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError
+};
+const TYPED_ARRAY_NAMES = /* @__PURE__ */ new Set([
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+]);
+const REFUSED_TAG = /^\[object (?:Promise|WeakMap|WeakSet|WeakRef|FinalizationRegistry|SharedArrayBuffer|Symbol|Arguments|Generator|AsyncGenerator|[A-Za-z ]+ Iterator|Blob|File|FileList|ImageData|ImageBitmap|OffscreenCanvas|CryptoKey|MessagePort|ReadableStream|WritableStream|TransformStream|VideoFrame|AudioData|RTCCertificate|FileSystemHandle|FileSystemFileHandle|FileSystemDirectoryHandle|GPUCompilationMessage|global|Window|Intl\.[A-Za-z]+)\]$/;
+const getter = (owner, name) => {
+  const found = Object.getOwnPropertyDescriptor(owner, name)?.get;
+  if (!found)
+    throw new Error(`valueCodec: ${String(name)} has no getter`);
+  return found;
+};
+const MAP_SIZE = getter(Map.prototype, "size");
+const SET_SIZE = getter(Set.prototype, "size");
+const ARRAY_BUFFER_BYTE_LENGTH = getter(ArrayBuffer.prototype, "byteLength");
+const DATA_VIEW_BYTE_LENGTH = getter(DataView.prototype, "byteLength");
+const REGEXP_SOURCE = getter(RegExp.prototype, "source");
+const REGEXP_FLAGS = getter(RegExp.prototype, "flags");
+const TYPED_ARRAY_NAME = getter(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag);
+const holds = (call) => {
+  try {
+    call();
+    return true;
+  } catch {
+    return false;
+  }
+};
+const cloneError = (what) => {
+  const message = `${what} could not be cloned.`;
+  const DomException = globalThis.DOMException;
+  if (typeof DomException === "function") {
+    return new DomException(message, "DataCloneError");
+  }
+  const error = new Error(message);
+  error.name = "DataCloneError";
+  return error;
+};
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_VALUES = new Map([...BASE64].map((char, index) => [char, index]));
+const toBase64 = (bytes) => {
+  const parts = [];
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    parts.push(BASE64[n >> 18 & 63] + BASE64[n >> 12 & 63] + BASE64[n >> 6 & 63] + BASE64[n & 63]);
+  }
+  const rest = bytes.length - i;
+  if (rest === 1) {
+    const n = bytes[i] << 16;
+    parts.push(`${BASE64[n >> 18 & 63]}${BASE64[n >> 12 & 63]}==`);
+  } else if (rest === 2) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8;
+    parts.push(`${BASE64[n >> 18 & 63]}${BASE64[n >> 12 & 63]}${BASE64[n >> 6 & 63]}=`);
+  }
+  return parts.join("");
+};
+const fromBase64 = (text) => {
+  const digits = text.replace(/=+$/, "");
+  const bytes = new Uint8Array(Math.floor(digits.length * 3 / 4));
+  let bits = 0;
+  let pending = 0;
+  let at = 0;
+  for (const char of digits) {
+    const value = BASE64_VALUES.get(char);
+    if (value === void 0)
+      throw new Error("valueCodec: the stored bytes are not base64.");
+    pending = (pending << 6 | value) & 16777215;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes[at] = pending >> bits & 255;
+      at += 1;
+    }
+  }
+  return bytes;
+};
+const numberNode = (value) => {
+  if (Number.isNaN(value))
+    return ["n", "NaN"];
+  if (value === Infinity)
+    return ["n", "Infinity"];
+  if (value === -Infinity)
+    return ["n", "-Infinity"];
+  if (Object.is(value, -0))
+    return ["n", "-0"];
+  return value;
+};
+function encodeValue(value) {
+  const ids = /* @__PURE__ */ new Map();
+  const encode = (input) => {
+    switch (typeof input) {
+      case "string":
+      case "boolean":
+        return input;
+      case "number":
+        return numberNode(input);
+      case "undefined":
+        return ["u"];
+      case "bigint":
+        return ["b", input.toString()];
+      case "symbol":
+        throw cloneError("A symbol");
+      case "function":
+        throw cloneError("A function");
+    }
+    if (input === null)
+      return null;
+    const object = input;
+    const seen = ids.get(object);
+    if (seen !== void 0)
+      return ["r", seen];
+    ids.set(object, ids.size);
+    return encodeObject(object);
+  };
+  const properties = (object) => {
+    const entries = [];
+    for (const key of Object.keys(object)) {
+      entries.push(key, encode(object[key]));
+    }
+    return entries;
+  };
+  const encodeObject = (object) => {
+    if (Array.isArray(object)) {
+      return ["a", object.length, properties(object)];
+    }
+    if (holds(() => Date.prototype.getTime.call(object))) {
+      return ["D", numberNode(Date.prototype.getTime.call(object))];
+    }
+    if (object !== RegExp.prototype && holds(() => REGEXP_SOURCE.call(object))) {
+      return ["R", REGEXP_SOURCE.call(object), REGEXP_FLAGS.call(object)];
+    }
+    if (holds(() => MAP_SIZE.call(object))) {
+      const entries = [];
+      Map.prototype.forEach.call(object, (entryValue, entryKey) => {
+        entries.push(encode(entryKey), encode(entryValue));
+      });
+      return ["M", entries];
+    }
+    if (holds(() => SET_SIZE.call(object))) {
+      const members = [];
+      Set.prototype.forEach.call(object, (member) => {
+        members.push(encode(member));
+      });
+      return ["S", members];
+    }
+    if (holds(() => ARRAY_BUFFER_BYTE_LENGTH.call(object))) {
+      if (object.detached === true)
+        throw cloneError("A detached ArrayBuffer");
+      return ["B", toBase64(new Uint8Array(object))];
+    }
+    if (ArrayBuffer.isView(object)) {
+      if (holds(() => DATA_VIEW_BYTE_LENGTH.call(object))) {
+        const view = object;
+        return ["V", encode(view.buffer), view.byteOffset, view.byteLength];
+      }
+      const name = TYPED_ARRAY_NAME.call(object);
+      if (typeof name === "string" && TYPED_ARRAY_NAMES.has(name)) {
+        const view = object;
+        return ["T", name, encode(view.buffer), view.byteOffset, view.length];
+      }
+      throw cloneError("An ArrayBuffer view");
+    }
+    if (holds(() => Number.prototype.valueOf.call(object))) {
+      return ["N", numberNode(Number.prototype.valueOf.call(object))];
+    }
+    if (holds(() => String.prototype.valueOf.call(object))) {
+      return ["Z", String.prototype.valueOf.call(object)];
+    }
+    if (holds(() => Boolean.prototype.valueOf.call(object))) {
+      return ["Q", Boolean.prototype.valueOf.call(object)];
+    }
+    if (typeof BigInt === "function" && holds(() => BigInt.prototype.valueOf.call(object))) {
+      return ["G", BigInt.prototype.valueOf.call(object).toString()];
+    }
+    if (holds(() => Symbol.prototype.valueOf.call(object))) {
+      throw cloneError("A Symbol object");
+    }
+    const tag = Object.prototype.toString.call(object);
+    if (isError(object, tag)) {
+      return encodeError(object);
+    }
+    if (REFUSED_TAG.test(tag)) {
+      throw cloneError(tag.slice(8, -1));
+    }
+    return ["o", properties(object)];
+  };
+  const encodeError = (error) => {
+    const name = String(error.name);
+    const prototypeName = Object.prototype.hasOwnProperty.call(ERROR_CONSTRUCTORS, name) ? name : "Error";
+    const messageDescriptor = Object.getOwnPropertyDescriptor(error, "message");
+    const message = messageDescriptor && "value" in messageDescriptor ? String(messageDescriptor.value) : null;
+    const stack = error.stack;
+    const node = ["E", prototypeName, message, typeof stack === "string" ? stack : null];
+    const causeDescriptor = Object.getOwnPropertyDescriptor(error, "cause");
+    if (causeDescriptor && "value" in causeDescriptor) {
+      node.push(encode(causeDescriptor.value));
+    }
+    return node;
+  };
+  return JSON.stringify([FORMAT, encode(value)]);
+}
+const isError = (object, tag) => {
+  const errorIs = Error.isError;
+  return typeof errorIs === "function" ? errorIs(object) : tag === "[object Error]";
+};
+const defineOwn = (target, key, value) => {
+  Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+};
+function decodeValue(text) {
+  const parsed = JSON.parse(text);
+  if (!Array.isArray(parsed) || parsed.length !== 2 || parsed[0] !== FORMAT) {
+    throw new Error("valueCodec: the stored value is not one the key-value store wrote.");
+  }
+  const objects = [];
+  const malformed = () => new Error("valueCodec: the stored value is malformed.");
+  const reserve = () => {
+    objects.push(void 0);
+    return objects.length - 1;
+  };
+  const register = (object) => {
+    objects.push(object);
+    return object;
+  };
+  const decodeNumber = (node) => {
+    const decoded = decode(node);
+    if (typeof decoded !== "number")
+      throw malformed();
+    return decoded;
+  };
+  const decodeProperties = (target, entries) => {
+    if (!Array.isArray(entries) || entries.length % 2 !== 0)
+      throw malformed();
+    for (let i = 0; i < entries.length; i += 2) {
+      const key = entries[i];
+      if (typeof key !== "string")
+        throw malformed();
+      defineOwn(target, key, decode(entries[i + 1]));
+    }
+  };
+  const decode = (node) => {
+    if (node === null || typeof node === "string" || typeof node === "number" || typeof node === "boolean") {
+      return node;
+    }
+    if (!Array.isArray(node) || typeof node[0] !== "string")
+      throw malformed();
+    switch (node[0]) {
+      case "u":
+        return void 0;
+      case "n":
+        switch (node[1]) {
+          case "NaN":
+            return NaN;
+          case "Infinity":
+            return Infinity;
+          case "-Infinity":
+            return -Infinity;
+          case "-0":
+            return -0;
+          default:
+            throw malformed();
+        }
+      case "b":
+        return BigInt(String(node[1]));
+      case "r": {
+        const id = node[1];
+        if (typeof id !== "number" || id < 0 || id >= objects.length)
+          throw malformed();
+        return objects[id];
+      }
+      case "o": {
+        const object = register({});
+        decodeProperties(object, node[1]);
+        return object;
+      }
+      case "a": {
+        if (typeof node[1] !== "number")
+          throw malformed();
+        const array = register(new Array(node[1]));
+        decodeProperties(array, node[2]);
+        return array;
+      }
+      case "D": {
+        const id = reserve();
+        const date = new Date(decodeNumber(node[1]));
+        objects[id] = date;
+        return date;
+      }
+      case "R":
+        return register(new RegExp(String(node[1]), String(node[2])));
+      case "M": {
+        const map = register(/* @__PURE__ */ new Map());
+        const entries = node[1];
+        if (!Array.isArray(entries) || entries.length % 2 !== 0)
+          throw malformed();
+        for (let i = 0; i < entries.length; i += 2) {
+          const key = decode(entries[i]);
+          map.set(key, decode(entries[i + 1]));
+        }
+        return map;
+      }
+      case "S": {
+        const set = register(/* @__PURE__ */ new Set());
+        const members = node[1];
+        if (!Array.isArray(members))
+          throw malformed();
+        for (const member of members)
+          set.add(decode(member));
+        return set;
+      }
+      case "B": {
+        const bytes = fromBase64(String(node[1]));
+        return register(bytes.buffer);
+      }
+      case "V": {
+        const id = reserve();
+        const buffer = decode(node[1]);
+        if (!(buffer instanceof ArrayBuffer))
+          throw malformed();
+        const view = new DataView(buffer, Number(node[2]), Number(node[3]));
+        objects[id] = view;
+        return view;
+      }
+      case "T": {
+        const name = String(node[1]);
+        const Constructor = globalThis[name];
+        if (!TYPED_ARRAY_NAMES.has(name) || typeof Constructor !== "function")
+          throw malformed();
+        const id = reserve();
+        const buffer = decode(node[2]);
+        if (!(buffer instanceof ArrayBuffer))
+          throw malformed();
+        const view = new Constructor(buffer, Number(node[3]), Number(node[4]));
+        objects[id] = view;
+        return view;
+      }
+      case "N": {
+        const id = reserve();
+        const boxed = new Number(decodeNumber(node[1]));
+        objects[id] = boxed;
+        return boxed;
+      }
+      case "Z":
+        return register(new String(String(node[1])));
+      case "Q":
+        return register(new Boolean(node[1] === true));
+      case "G":
+        return register(Object(BigInt(String(node[1]))));
+      case "E":
+        return decodeError(node);
+      default:
+        throw malformed();
+    }
+  };
+  const decodeError = (node) => {
+    const name = String(node[1]);
+    const Constructor = Object.prototype.hasOwnProperty.call(ERROR_CONSTRUCTORS, name) ? ERROR_CONSTRUCTORS[name] : Error;
+    const message = node[2];
+    const error = typeof message === "string" ? new Constructor(message) : new Constructor();
+    register(error);
+    const stack = node[3];
+    try {
+      if (typeof stack === "string") {
+        Object.defineProperty(error, "stack", { value: stack, writable: true, enumerable: false, configurable: true });
+      } else {
+        delete error.stack;
+      }
+    } catch {
+    }
+    if (node.length > 4) {
+      Object.defineProperty(error, "cause", {
+        value: decode(node[4]),
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    return error;
+  };
+  return decode(parsed[1]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeValue,
+  encodeValue
+});

package/dist/cjs/features/migrations/dataExport.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Data export utilities for cross-adapter migration and backup.
+ * Supports exporting data to portable formats (JSON, SQL, CSV).
+ */
+import type { StorageAdapter } from '../../core/contracts/index.js';
+/**
+ * Export format types.
+ */
+export type ExportFormat = 'json' | 'sql' | 'csv';
+/**
+ * Options for data export.
+ */
+export interface DataExportOptions {
+    /** Tables to export (all if not specified) */
+    tables?: string[];
+    /** Include schema/DDL statements */
+    includeSchema?: boolean;
+    /** Format for export */
+    format?: ExportFormat;
+    /** Batch size for large exports */
+    batchSize?: number;
+    /** Whether to pretty-print JSON */
+    pretty?: boolean;
+}
+/**
+ * Exported data structure.
+ */
+export interface ExportedData {
+    version: string;
+    exportedAt: string;
+    adapter: string;
+    schema?: TableSchema[];
+    data: Record<string, unknown[]>;
+}
+/**
+ * Table schema information.
+ */
+export interface TableSchema {
+    name: string;
+    columns: ColumnInfo[];
+    primaryKeys?: string[];
+    indexes?: IndexInfo[];
+}
+/**
+ * Column information.
+ */
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    defaultValue?: string;
+}
+/**
+ * Index information.
+ */
+export interface IndexInfo {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+}
+/**
+ * Export data from an adapter to a portable format.
+ */
+export declare function exportData(adapter: StorageAdapter, options?: DataExportOptions): Promise<ExportedData>;
+/**
+ * Export data as JSON string.
+ */
+export declare function exportAsJSON(adapter: StorageAdapter, options?: DataExportOptions): Promise<string>;
+/**
+ * Export data as SQL statements.
+ */
+export declare function exportAsSQL(adapter: StorageAdapter, options?: DataExportOptions): Promise<string>;
+/**
+ * Export data as CSV (one file per table).
+ */
+export declare function exportAsCSV(adapter: StorageAdapter, options?: DataExportOptions): Promise<Record<string, string>>;
+//# sourceMappingURL=dataExport.d.ts.map

package/dist/cjs/features/migrations/dataExport.js

@@ -0,0 +1,194 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dataExport_exports = {};
+__export(dataExport_exports, {
+  exportAsCSV: () => exportAsCSV,
+  exportAsJSON: () => exportAsJSON,
+  exportAsSQL: () => exportAsSQL,
+  exportData: () => exportData
+});
+module.exports = __toCommonJS(dataExport_exports);
+async function exportData(adapter, options = {}) {
+  const { tables, includeSchema = true, batchSize = 1e3 } = options;
+  const exportedData = {
+    version: "1.0.0",
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    adapter: "sql-storage-adapter",
+    data: {}
+  };
+  const tablesToExport = tables || await getTables(adapter);
+  if (includeSchema) {
+    exportedData.schema = await Promise.all(tablesToExport.map((table) => getTableSchema(adapter, table)));
+  }
+  for (const table of tablesToExport) {
+    const rows = [];
+    let offset = 0;
+    let batch;
+    do {
+      batch = await adapter.all(`SELECT * FROM ${escapeIdentifier(table)} LIMIT ${batchSize} OFFSET ${offset}`);
+      rows.push(...batch);
+      offset += batchSize;
+    } while (batch.length === batchSize);
+    exportedData.data[table] = rows;
+  }
+  return exportedData;
+}
+async function exportAsJSON(adapter, options = {}) {
+  const data = await exportData(adapter, options);
+  return JSON.stringify(data, null, options.pretty ? 2 : 0);
+}
+async function exportAsSQL(adapter, options = {}) {
+  const data = await exportData(adapter, options);
+  const lines = [];
+  lines.push("-- SQL Export from sql-storage-adapter");
+  lines.push(`-- Generated at: ${data.exportedAt}`);
+  lines.push("");
+  if (data.schema) {
+    for (const table of data.schema) {
+      lines.push(`-- Table: ${table.name}`);
+      lines.push(generateCreateTableSQL(table));
+      lines.push("");
+    }
+  }
+  for (const [tableName, rows] of Object.entries(data.data)) {
+    if (rows.length === 0)
+      continue;
+    lines.push(`-- Data for table: ${tableName}`);
+    for (const row of rows) {
+      lines.push(generateInsertSQL(tableName, row));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function exportAsCSV(adapter, options = {}) {
+  const data = await exportData(adapter, options);
+  const csvFiles = {};
+  for (const [tableName, rows] of Object.entries(data.data)) {
+    if (rows.length === 0) {
+      csvFiles[tableName] = "";
+      continue;
+    }
+    const firstRow = rows[0];
+    const headers = Object.keys(firstRow);
+    const lines = [];
+    lines.push(headers.map(escapeCSVValue).join(","));
+    for (const row of rows) {
+      const values = headers.map((header) => escapeCSVValue(String(row[header] ?? "")));
+      lines.push(values.join(","));
+    }
+    csvFiles[tableName] = lines.join("\n");
+  }
+  return csvFiles;
+}
+async function getTables(adapter) {
+  try {
+    const rows = await adapter.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+    return rows.map((r) => r.name);
+  } catch {
+    try {
+      const rows = await adapter.all(`SELECT tablename AS name FROM pg_tables WHERE schemaname = current_schema() ORDER BY tablename`);
+      return rows.map((r) => r.name);
+    } catch {
+      throw new Error("Unable to retrieve table list from adapter");
+    }
+  }
+}
+async function getTableSchema(adapter, table) {
+  try {
+    const columns = await adapter.all(`PRAGMA table_info(${escapeIdentifier(table)})`);
+    return {
+      name: table,
+      columns: columns.map((col) => ({
+        name: col.name,
+        type: col.type,
+        nullable: col.notnull === 0,
+        defaultValue: col.dflt_value ?? void 0
+      }))
+    };
+  } catch {
+    try {
+      const columns = await adapter.all(`SELECT column_name, data_type, is_nullable, column_default
+         FROM information_schema.columns
+         WHERE table_schema = current_schema() AND table_name = $1
+         ORDER BY ordinal_position`, [table]);
+      return {
+        name: table,
+        columns: columns.map((col) => ({
+          name: col.column_name,
+          type: col.data_type,
+          nullable: col.is_nullable === "YES",
+          defaultValue: col.column_default ?? void 0
+        }))
+      };
+    } catch {
+      return {
+        name: table,
+        columns: []
+      };
+    }
+  }
+}
+function generateCreateTableSQL(schema) {
+  if (schema.columns.length === 0) {
+    return `CREATE TABLE ${escapeIdentifier(schema.name)} ();`;
+  }
+  const columnDefs = schema.columns.map((col) => {
+    let def = `  ${escapeIdentifier(col.name)} ${col.type}`;
+    if (!col.nullable)
+      def += " NOT NULL";
+    if (col.defaultValue)
+      def += ` DEFAULT ${col.defaultValue}`;
+    return def;
+  });
+  return `CREATE TABLE ${escapeIdentifier(schema.name)} (
+${columnDefs.join(",\n")}
+);`;
+}
+function generateInsertSQL(table, row) {
+  const columns = Object.keys(row);
+  const values = columns.map((col) => escapeSQLValue(row[col]));
+  return `INSERT INTO ${escapeIdentifier(table)} (${columns.map(escapeIdentifier).join(", ")}) VALUES (${values.join(", ")});`;
+}
+function escapeIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function escapeSQLValue(value) {
+  if (value === null || value === void 0)
+    return "NULL";
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "1" : "0";
+  if (value instanceof Date)
+    return `'${value.toISOString()}'`;
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function escapeCSVValue(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportAsCSV,
+  exportAsJSON,
+  exportAsSQL,
+  exportData
+});