alinea 2.0.0-preview.7 → 2.0.0-preview.9

package/dist/chunks/chunk-AIU6CMVT.js

@@ -0,0 +1,495 @@
+import {
+  Rollback,
+  txGenerator
+} from "./chunk-N47Y62CI.js";
+import {
+  eq
+} from "./chunk-XCZXR3C2.js";
+import {
+  Column,
+  JsonColumn,
+  column,
+  columnConfig,
+  formatColumn,
+  table
+} from "./chunk-MOWR65LM.js";
+import {
+  Sql,
+  getData,
+  getQuery,
+  getSql,
+  getTable,
+  hasQuery,
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/core/Dialect.js
+var Dialect = class {
+  runtime;
+  #createEmitter;
+  constructor(runtime, createEmitter) {
+    this.runtime = runtime;
+    this.#createEmitter = createEmitter;
+  }
+  emit = (input) => {
+    const sql2 = hasQuery(input) ? getQuery(input) : getSql(input);
+    const emitter = new this.#createEmitter(this.runtime);
+    sql2.emit(emitter);
+    return emitter;
+  };
+  inline = (input) => {
+    const sql2 = hasQuery(input) ? getQuery(input) : getSql(input);
+    const emitter = new this.#createEmitter(this.runtime);
+    sql2.inlineValues().emit(emitter);
+    return emitter.sql;
+  };
+};
+
+// node_modules/rado/dist/core/Param.js
+var NamedParam = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var ValueParam = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+
+// node_modules/rado/dist/core/Emitter.js
+var Emitter = class {
+  #runtime;
+  sql = "";
+  params = [];
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  get hasParams() {
+    return this.params.length > 0;
+  }
+  bind(inputs) {
+    return this.params.map((param) => {
+      if (param instanceof ValueParam) return this.processValue(param.value);
+      if (inputs && param.name in inputs)
+        return this.processValue(inputs[param.name]);
+      throw new Error(`Missing input for named parameter: ${param.name}`);
+    });
+  }
+  processValue(value) {
+    return value;
+  }
+  emitIdentifierOrSelf(value) {
+    if (value === Sql.SELF_TARGET) {
+      if (!this.#selfName) throw new Error("Self target not defined");
+      this.emitIdentifier(this.#selfName);
+    } else {
+      this.emitIdentifier(value);
+    }
+  }
+  emitUnsafe(value) {
+    this.sql += value;
+  }
+  #selfName;
+  emitSelf(inner, name) {
+    this.#selfName = name;
+    inner.emit(this);
+    this.#selfName = void 0;
+  }
+  #inlineFields = false;
+  inlineFields(inner, withTableName) {
+    const previous = this.#inlineFields;
+    this.#inlineFields = !withTableName;
+    inner.emit(this);
+    this.#inlineFields = previous;
+  }
+  #inlineValues = false;
+  inlineValues(inner) {
+    const previous = this.#inlineValues;
+    this.#inlineValues = true;
+    inner.emit(this);
+    this.#inlineValues = previous;
+  }
+  emitField({ targetName, fieldName }) {
+    if (this.#inlineFields) return this.emitIdentifier(fieldName);
+    this.emitIdentifierOrSelf(targetName);
+    this.emitUnsafe(".");
+    this.emitIdentifier(fieldName);
+  }
+  emitValueOrInline(value) {
+    if (this.#inlineValues) this.emitInline(value);
+    else this.emitValue(value);
+  }
+  emitUniversal(runtimes) {
+    const sql2 = runtimes[this.#runtime] ?? runtimes.default;
+    if (!sql2) throw new Error("Unsupported runtime");
+    getSql(sql2).emit(this);
+  }
+};
+
+// node_modules/rado/dist/sqlite/dialect.js
+var DOUBLE_QUOTE = '"';
+var ESCAPE_DOUBLE_QUOTE = '""';
+var MATCH_DOUBLE_QUOTE = /"/g;
+var SINGLE_QUOTE = "'";
+var ESCAPE_SINGLE_QUOTE = "''";
+var MATCH_SINGLE_QUOTE = /'/g;
+var sqliteDialect = new Dialect(
+  "sqlite",
+  class extends Emitter {
+    processValue(value) {
+      return typeof value === "boolean" ? value ? 1 : 0 : value;
+    }
+    emitValue(value) {
+      this.params.push(new ValueParam(value));
+      this.sql += "?";
+    }
+    emitPlaceholder(name) {
+      this.params.push(new NamedParam(name));
+      this.sql += "?";
+    }
+    emitJsonPath({ target, asSql, segments }) {
+      target.emit(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map(
+          (p) => typeof p === "number" ? `[${p}]` : `.${JSON.stringify(p)}`
+        ).join("")}`
+      );
+    }
+    emitInline(value) {
+      if (value === null || value === void 0) return this.sql += "null";
+      if (typeof value === "number") return this.sql += value;
+      if (typeof value === "string")
+        return this.sql += this.quoteString(value);
+      if (typeof value === "boolean") return this.sql += value ? "1" : "0";
+      this.sql += `json(${this.quoteString(JSON.stringify(value))})`;
+    }
+    emitIdentifier(identifier) {
+      this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
+    }
+    quoteString(input) {
+      return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
+    }
+  }
+);
+
+// node_modules/rado/dist/sqlite/columns.js
+function boolean(name) {
+  return new Column({
+    name,
+    type: column.integer(),
+    mapFromDriverValue(value) {
+      return value === 1;
+    },
+    mapToDriverValue(value) {
+      return value ? 1 : 0;
+    }
+  });
+}
+function integer(...args) {
+  const { name, options } = columnConfig(args);
+  if (options?.mode === "timestamp" || options?.mode === "timestamp_ms") {
+    const scale = options.mode === "timestamp" ? 1e3 : 1;
+    return new Column({
+      name,
+      type: column.integer(),
+      mapFromDriverValue(value) {
+        if (value === null) return null;
+        return new Date(value * scale);
+      },
+      mapToDriverValue(value) {
+        return Math.floor(value.getTime() / scale);
+      }
+    });
+  }
+  if (options?.mode === "boolean") return boolean();
+  return new Column({ name, type: column.integer() });
+}
+function text(...args) {
+  const { name, options } = columnConfig(args);
+  if (options?.mode === "json")
+    return new JsonColumn({
+      name,
+      type: column.text(options?.length),
+      mapToDriverValue(value) {
+        return JSON.stringify(value);
+      },
+      mapFromDriverValue(value) {
+        return JSON.parse(value);
+      }
+    });
+  return new Column({ name, type: column.text(options?.length) });
+}
+
+// node_modules/rado/dist/sqlite/diff.js
+var TableInfo = table("TableInfo", {
+  cid: integer().notNull(),
+  name: text().notNull(),
+  type: text().notNull(),
+  notnull: boolean().notNull(),
+  dflt_value: text(),
+  pk: integer().notNull()
+});
+var SqliteMaster = table("SqliteMaster", {
+  type: text().notNull(),
+  name: text().notNull(),
+  tbl_name: text().notNull(),
+  rootpage: integer().notNull(),
+  sql: text().notNull()
+});
+var inline = (sql2) => sqliteDialect.inline(sql2);
+var sqliteDiff = (targetTable) => {
+  return txGenerator(function* (tx) {
+    const tableApi = getTable(targetTable);
+    const columnInfo = yield* tx.select(TableInfo).from(sql`pragma_table_info(${sql.inline(tableApi.name)}) as "TableInfo"`);
+    if (columnInfo.length === 0) return tableApi.create().map(inline);
+    const indexInfo = yield* tx.select(SqliteMaster).from(sql`sqlite_master as "SqliteMaster"`).where(
+      eq(SqliteMaster.tbl_name, tableApi.name),
+      eq(SqliteMaster.type, "index")
+    );
+    const hasSinglePrimaryKey = columnInfo.reduce((acc, column2) => acc + column2.pk, 0) === 1;
+    const localColumns = new Map(
+      columnInfo.map((column2) => {
+        return [
+          column2.name,
+          inline(
+            formatColumn({
+              type: sql.unsafe(column2.type.toLowerCase()),
+              notNull: column2.notnull,
+              primary: hasSinglePrimaryKey && column2.pk === 1,
+              defaultValue: column2.dflt_value !== null ? sql.unsafe(column2.dflt_value) : void 0
+            })
+          )
+        ];
+      })
+    );
+    const schemaColumns = new Map(
+      Object.entries(tableApi.columns).map(([name, column2]) => {
+        const columnApi = getData(column2);
+        return [columnApi.name ?? name, inline(formatColumn(columnApi))];
+      })
+    );
+    const localIndexes = new Map(
+      indexInfo.filter((index) => !index.name.startsWith("sqlite_autoindex_")).map((index) => [index.name, index.sql])
+    );
+    const schemaIndexes = new Map(
+      Object.entries(tableApi.indexes()).map(([name, index]) => {
+        const indexApi = getData(index);
+        return [name, inline(indexApi.toSql(tableApi.name, name, false))];
+      })
+    );
+    const stmts = [];
+    const columnNames = /* @__PURE__ */ new Set([
+      ...localColumns.keys(),
+      ...schemaColumns.keys()
+    ]);
+    for (const columnName of columnNames) {
+      const localInstruction = localColumns.get(columnName);
+      const schemaInstruction = schemaColumns.get(columnName);
+      if (!schemaInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable: sql.identifier(tableApi.name),
+            dropColumn: sql.identifier(columnName)
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable: sql.identifier(tableApi.name),
+            addColumn: [
+              sql.identifier(columnName),
+              sql.unsafe(schemaInstruction)
+            ]
+          })
+        );
+      } else if (localInstruction !== schemaInstruction) {
+        return recreate();
+      }
+    }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...localIndexes.keys(),
+      ...schemaIndexes.keys()
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = localIndexes.get(indexName);
+      const schemaInstruction = schemaIndexes.get(indexName);
+      const dropLocal = sql.query({
+        dropIndex: sql.identifier(indexName)
+      });
+      if (!schemaInstruction) {
+        stmts.unshift(dropLocal);
+      } else if (schemaInstruction && !localInstruction) {
+        stmts.push(sql.unsafe(schemaInstruction));
+      } else if (schemaInstruction && localInstruction !== schemaInstruction) {
+        stmts.unshift(dropLocal);
+        stmts.push(sql.unsafe(schemaInstruction));
+      }
+    }
+    try {
+      yield* txGenerator(function* (sp) {
+        yield* sp.batch(stmts);
+        const [tableInfo] = yield* sp.select(SqliteMaster.sql).from(sql`sqlite_master as "SqliteMaster"`).where(
+          eq(SqliteMaster.tbl_name, tableApi.name),
+          eq(SqliteMaster.type, "table")
+        );
+        sp.rollback(tableInfo);
+      });
+    } catch (err) {
+      if (!(err instanceof Rollback)) throw err;
+      const localInstruction = err.data;
+      const schemaInstruction = inline(tableApi.createTable());
+      const stripStmt = (q) => q.slice("create table ".length);
+      if (stripStmt(localInstruction) !== stripStmt(schemaInstruction)) {
+        return recreate();
+      }
+    }
+    return stmts.map(inline);
+    function recreate() {
+      const tempName = `new_${tableApi.name}`;
+      const tempTable = table(tempName, tableApi.columns);
+      const missingColumns = new Set(
+        Array.from(columnNames).filter((name) => !localColumns.has(name))
+      );
+      const selection = Object.fromEntries(
+        Object.entries(tableApi.columns).map(([name, column2]) => {
+          const columnApi = getData(column2);
+          const key = columnApi.name ?? name;
+          if (missingColumns.has(key))
+            return [name, columnApi.defaultValue ?? sql`null`];
+          return [name, targetTable[name]];
+        })
+      );
+      return [
+        // Create a new temporary table with the new definition
+        tableApi.createTable(tempName),
+        // Copy the data from the old table to the new table
+        getQuery(
+          tx.insert(tempTable).select(tx.select(selection).from(targetTable))
+        ),
+        // Drop the old table
+        sql.query({ dropTable: sql.identifier(tableApi.name) }),
+        // Rename the temporary table to the old table name
+        sql.query({
+          alterTable: sql.identifier(tempName),
+          renameTo: sql.identifier(tableApi.name)
+        }),
+        // Create missing indexes
+        ...tableApi.createIndexes()
+      ].map(inline);
+    }
+  });
+};
+
+// node_modules/rado/dist/sqlite/statements.js
+var changesSchema = /^\s*(create|drop|alter|attach|detach|rollback)\b/i;
+var StatementCache = class {
+  #statements = /* @__PURE__ */ new Map();
+  #prepare;
+  #finalize;
+  #size;
+  constructor(prepare, finalize, size = 256) {
+    this.#prepare = prepare;
+    this.#finalize = finalize;
+    this.#size = size;
+  }
+  acquire(sql2) {
+    if (changesSchema.test(sql2)) {
+      this.clear();
+      return { statement: this.#prepare(sql2), users: 1, evicted: true };
+    }
+    let cached = this.#statements.get(sql2);
+    if (cached) {
+      this.#statements.delete(sql2);
+    } else {
+      cached = { statement: this.#prepare(sql2), users: 0, evicted: false };
+      if (this.#statements.size >= this.#size) {
+        const [oldest, entry] = this.#statements.entries().next().value;
+        this.#statements.delete(oldest);
+        this.#evict(entry);
+      }
+    }
+    this.#statements.set(sql2, cached);
+    cached.users++;
+    return cached;
+  }
+  release(cached) {
+    cached.users--;
+    if (cached.evicted && cached.users === 0) this.#finalize(cached.statement);
+  }
+  invalidate(sql2) {
+    if (changesSchema.test(sql2)) this.clear();
+  }
+  clear() {
+    for (const cached of this.#statements.values()) this.#evict(cached);
+    this.#statements.clear();
+  }
+  #evict(cached) {
+    cached.evicted = true;
+    if (cached.users === 0) this.#finalize(cached.statement);
+  }
+};
+var ReusedStatement = class {
+  stmt;
+  #statements;
+  #cached;
+  constructor(statements, sql2) {
+    this.#statements = statements;
+    this.#cached = statements.acquire(sql2);
+    this.stmt = this.#cached.statement;
+  }
+  free() {
+    if (!this.#cached) return;
+    this.#statements.release(this.#cached);
+    this.#cached = void 0;
+  }
+};
+
+// node_modules/rado/dist/sqlite/transactions.js
+var locks = /* @__PURE__ */ new WeakMap();
+function execTransaction(driver, depth, wrap, run, options) {
+  const needsLock = options.async;
+  const behavior = options.behavior ?? "deferred";
+  if (!needsLock) return transact();
+  let trigger;
+  const lock = new Promise((resolve) => trigger = resolve);
+  const current = Promise.resolve(locks.get(driver));
+  locks.set(driver, lock);
+  return current.then(transact).finally(trigger);
+  function transact() {
+    try {
+      driver.exec(depth > 0 ? `savepoint d${depth}` : `begin ${behavior}`);
+      const result = run(wrap(depth + 1));
+      if (result instanceof Promise) return result.then(release, rollback);
+      return release(result);
+    } catch (error) {
+      return rollback(error);
+    }
+  }
+  function release(result) {
+    driver.exec(depth > 0 ? `release d${depth}` : "commit");
+    return result;
+  }
+  function rollback(error) {
+    try {
+      driver.exec(depth > 0 ? `rollback to d${depth}` : "rollback");
+    } catch {
+    }
+    throw error;
+  }
+}
+
+export {
+  Dialect,
+  NamedParam,
+  ValueParam,
+  Emitter,
+  sqliteDialect,
+  sqliteDiff,
+  StatementCache,
+  ReusedStatement,
+  execTransaction
+};

package/dist/chunks/chunk-ASYKC6IE.js

@@ -0,0 +1,103 @@
+import {
+  Column,
+  ColumnType,
+  JsonColumn,
+  column
+} from "./chunk-MOWR65LM.js";
+import {
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/universal/columns.js
+var idType = new ColumnType(
+  "id",
+  [],
+  sql.universal({
+    sqlite: sql`integer`,
+    postgres: sql`integer generated always as identity`,
+    mysql: sql`int not null auto_increment`
+  })
+);
+var blobType = new ColumnType(
+  "blob",
+  [],
+  sql.universal({
+    postgres: sql`bytea`,
+    default: sql`blob`
+  })
+);
+var numberType = new ColumnType(
+  "number",
+  [],
+  sql.universal({
+    mysql: sql`double`,
+    default: sql`numeric`
+  })
+);
+var jsonbType = new ColumnType(
+  "json",
+  [],
+  sql.universal({
+    mysql: sql`json`,
+    default: sql`jsonb`
+  })
+);
+function id(name) {
+  return new Column({
+    name,
+    type: idType,
+    primary: true,
+    notNull: true
+  });
+}
+function text(name) {
+  return new Column({ name, type: column.text() });
+}
+function varchar(name, options) {
+  return new Column({ name, type: column.varchar(options?.length) });
+}
+function integer(name) {
+  return new Column({ name, type: column.integer() });
+}
+function number(name) {
+  return new Column({ name, type: numberType, mapFromDriverValue: Number });
+}
+function boolean(name) {
+  return new Column({
+    name,
+    type: column.boolean(),
+    mapFromDriverValue: Boolean
+  });
+}
+function json(name) {
+  return new JsonColumn({
+    name,
+    type: column.json(),
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    },
+    mapFromDriverValue(value, { parsesJson }) {
+      return parsesJson ? value : JSON.parse(value);
+    }
+  });
+}
+function blob(name) {
+  return new Column({
+    name,
+    type: blobType,
+    mapFromDriverValue(value) {
+      return new Uint8Array(value);
+    }
+  });
+}
+
+export {
+  id,
+  text,
+  varchar,
+  integer,
+  number,
+  boolean,
+  json,
+  blob
+};

package/dist/chunks/chunk-ATF42T2B.js

@@ -0,0 +1,35 @@
+import {
+  getField,
+  getSql,
+  getTable,
+  hasField,
+  hasSql,
+  hasTable,
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/core/expr/Input.js
+function input(value, maybeField) {
+  const isObject = value && typeof value === "object";
+  if (isObject && hasTable(value))
+    return sql.identifier(getTable(value).aliased);
+  if (isObject && hasSql(value)) return getSql(value);
+  const fieldSource = maybeField && typeof maybeField === "object" && hasField(maybeField) && getField(maybeField).source;
+  return fieldSource && "mapToDriverValue" in fieldSource ? mapToColumn(fieldSource, value) : sql.value(value);
+}
+function mapToColumn({ mapToDriverValue, type }, expr) {
+  const isObject = expr && typeof expr === "object";
+  if (isObject && hasSql(expr)) return getSql(expr);
+  if (Array.isArray(expr) && type.kind === "array") {
+    if (!mapToDriverValue) return input(expr);
+    return input(mapToDriverValue(expr));
+  }
+  return input(
+    expr !== null && mapToDriverValue ? mapToDriverValue(expr) : expr
+  );
+}
+
+export {
+  input,
+  mapToColumn
+};

package/dist/chunks/{chunk-6P4UVRPH.js → chunk-DWR5A5KL.js}

@@ -1,7 +1,7 @@
 // package.json with { type: 'json' }
 var package_default = {
   name: "alinea",
-  version: "2.0.0-preview.7",
+  version: "2.0.0-preview.9",
   description: "Headless git-based CMS",
   repository: "github:alineacms/alinea",
   license: "MIT",
@@ -28,6 +28,10 @@ var package_default = {
     },
     "./*.cjs": "./dist/*.cjs",
     "./*": "./dist/*.js",
+    "./database/driver/OverlayExtension": {
+      browser: "./dist/database/driver/OverlayExtension.browser.js",
+      default: "./dist/database/driver/OverlayExtension.js"
+    },
     "./core/media/CreatePreview": {
       "edge-light": "./dist/core/media/CreatePreview.js",
       worker: "./dist/core/media/CreatePreview.js",
@@ -69,6 +73,7 @@ var package_default = {
   },
   dependencies: {
     "@alinea/iso": "^0.3.3",
+    "@alinea/sqlite-wasm": "0.3.0",
     esbuild: "^0.28.0"
   },
   peerDependencies: {