@lunora/d1 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/packem_shared/MigrationRunner-BkEwQ-Ya.mjs

@@ -1,149 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { D1Client } from './D1Client-DA3flo1o.mjs';
-
-const TRACKING_TABLE_NAME = "__drizzle_migrations";
-const TRACKING_TABLE_DDL = `CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE_NAME} (id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL, created_at NUMERIC)`;
-const WHITESPACE_RE = /\s/u;
-const TRAILING_SEMICOLON_RE = /;\s*$/u;
-const SHA256_HEX_RE = /^[0-9a-f]{64}$/u;
-const assertSingleStatement = (migration) => {
-  const text = migration.sql;
-  let inSingle = false;
-  let inDouble = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-  let seenStatement = false;
-  for (let index = 0; index < text.length; index += 1) {
-    const character = text[index];
-    const next = text[index + 1];
-    if (inLineComment) {
-      if (character === "\n") {
-        inLineComment = false;
-      }
-      continue;
-    }
-    if (inBlockComment) {
-      if (character === "*" && next === "/") {
-        inBlockComment = false;
-        index += 1;
-      }
-      continue;
-    }
-    if (inSingle) {
-      if (character === "'") {
-        if (next === "'") {
-          index += 1;
-        } else {
-          inSingle = false;
-        }
-      }
-      continue;
-    }
-    if (inDouble) {
-      if (character === '"') {
-        if (next === '"') {
-          index += 1;
-        } else {
-          inDouble = false;
-        }
-      }
-      continue;
-    }
-    if (character === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (character === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (character === "-" && next === "-") {
-      inLineComment = true;
-      index += 1;
-      continue;
-    }
-    if (character === "/" && next === "*") {
-      inBlockComment = true;
-      index += 1;
-      continue;
-    }
-    if (character === ";") {
-      seenStatement = true;
-      continue;
-    }
-    if (seenStatement && character !== void 0 && !WHITESPACE_RE.test(character)) {
-      throw new Error(
-        `Migration "${migration.name}" (v${String(migration.version)}) contains more than one SQL statement. Split it into separate migrations — batch() runs them atomically.`
-      );
-    }
-  }
-};
-const hashMigration = async (text) => {
-  const bytes = new TextEncoder().encode(text);
-  const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
-};
-class MigrationRunner {
-  client;
-  migrations;
-  /**
-   * Accepts either a {@link D1Client} (preferred — gets typed batches +
-   * drizzle handle for free) or a raw `D1DatabaseLike` binding (wrapped on
-   * the caller's behalf so existing `@lunora/cli` callers keep working).
-   */
-  constructor(database, migrations) {
-    this.client = database instanceof D1Client ? database : new D1Client(database);
-    this.migrations = [...migrations].toSorted((a, b) => a.version - b.version);
-    this.assertUniqueVersions();
-    this.assertUniqueSql();
-  }
-  async run() {
-    await this.client.drizzle.run(sql.raw(TRACKING_TABLE_DDL));
-    const appliedRows = await this.client.drizzle.all(sql.raw(`SELECT hash FROM ${TRACKING_TABLE_NAME}`));
-    const appliedHashes = new Set(appliedRows.map((row) => row.hash));
-    const applied = [];
-    const skipped = [];
-    const hashes = await Promise.all(this.migrations.map(async (migration) => hashMigration(migration.sql)));
-    for (const [index, migration] of this.migrations.entries()) {
-      const hash = hashes[index];
-      if (appliedHashes.has(hash)) {
-        skipped.push({ name: migration.name, version: migration.version });
-        continue;
-      }
-      await this.applyOne(migration, hash);
-      applied.push({ name: migration.name, version: migration.version });
-    }
-    return { applied, skipped };
-  }
-  async applyOne(migration, hash) {
-    assertSingleStatement(migration);
-    const statementText = migration.sql.replace(TRAILING_SEMICOLON_RE, "").trim();
-    if (!SHA256_HEX_RE.test(hash)) {
-      throw new Error(`migration "${migration.name}" produced a non-hex hash; refusing to inline into SQL`);
-    }
-    const trackingInsertSql = `INSERT INTO ${TRACKING_TABLE_NAME} (hash, created_at) VALUES ('${hash}', ${String(Date.now())})`;
-    const items = [this.client.drizzle.run(sql.raw(statementText)), this.client.drizzle.run(sql.raw(trackingInsertSql))];
-    await this.client.batch(items);
-  }
-  assertUniqueVersions() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const m of this.migrations) {
-      if (seen.has(m.version)) {
-        throw new Error(`Duplicate migration version ${String(m.version)}`);
-      }
-      seen.add(m.version);
-    }
-  }
-  assertUniqueSql() {
-    const seen = /* @__PURE__ */ new Map();
-    for (const m of this.migrations) {
-      const previousVersion = seen.get(m.sql);
-      if (previousVersion !== void 0) {
-        throw new Error(`Migrations ${String(previousVersion)} and ${String(m.version)} have identical SQL — bump the content, not just the version.`);
-      }
-      seen.set(m.sql, m.version);
-    }
-  }
-}
-
-export { MigrationRunner };

package/dist/packem_shared/createD1CtxDb-BMR8J0dT.mjs

@@ -1,14 +0,0 @@
-import { createSqlCtxDb, readSqlCdcChanges, runSqlAggregateMigrations, runSqlCdcMigration, runSqlGlobalTableMigrations, runSqlRankMigrations, runSqlSearchMigrations, trimSqlCdcChanges } from '@lunora/sql-store';
-export { createSqlCtxDb, decodeGlobalRow } from '@lunora/sql-store';
-import sqliteDialect from './sqliteDialect-DqYnHPuu.mjs';
-
-const createD1ContextDatabase = (options) => createSqlCtxDb({ ...options, dialect: sqliteDialect });
-const runD1GlobalTableMigrations = (exec, schema) => runSqlGlobalTableMigrations(exec, schema, sqliteDialect);
-const runD1AggregateMigrations = (exec, schema) => runSqlAggregateMigrations(exec, schema, sqliteDialect);
-const runD1RankMigrations = (exec, schema) => runSqlRankMigrations(exec, schema, sqliteDialect);
-const runD1SearchMigrations = (exec, schema) => runSqlSearchMigrations(exec, schema, sqliteDialect);
-const runD1CdcMigration = (exec) => runSqlCdcMigration(exec, sqliteDialect);
-const readD1CdcChanges = (exec, options = {}) => readSqlCdcChanges(exec, options, sqliteDialect);
-const trimD1CdcChanges = (exec, throughSeq) => trimSqlCdcChanges(exec, throughSeq, sqliteDialect);
-
-export { createD1ContextDatabase as createD1CtxDb, readD1CdcChanges, runD1AggregateMigrations, runD1CdcMigration, runD1GlobalTableMigrations, runD1RankMigrations, runD1SearchMigrations, trimD1CdcChanges };

package/dist/packem_shared/exportGlobalRows-BGCPm_nA.mjs

@@ -1,122 +0,0 @@
-import { decodeGlobalRow } from '@lunora/sql-store';
-
-const DEFAULT_BATCH_SIZE = 200;
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-const selectGlobalTables = (schema, requested) => {
-  const isGlobal = (table) => schema.tables[table]?.shardMode?.kind === "global";
-  if (requested && requested.length > 0) {
-    return requested.filter((name) => isGlobal(name));
-  }
-  return Object.keys(schema.tables).filter((name) => isGlobal(name));
-};
-const decodeRow = (schema, table, row) => {
-  const definition = schema.tables[table];
-  if (!definition) {
-    return { _creationTime: row["_creationTime"], _id: row["id"] };
-  }
-  return decodeGlobalRow(definition, row);
-};
-const exportGlobalRows = async function* (exec, schema, args) {
-  const tables = selectGlobalTables(schema, args.tables);
-  const batchSize = args.batchSize ?? DEFAULT_BATCH_SIZE;
-  for (const table of tables) {
-    let offset = 0;
-    let hasMore = true;
-    while (hasMore) {
-      const rows = await exec.all(`SELECT * FROM ${quoteIdentifier(table)} LIMIT ? OFFSET ?`, [batchSize, offset]);
-      for (const row of rows) {
-        yield { doc: decodeRow(schema, table, row), table };
-      }
-      hasMore = rows.length === batchSize;
-      offset += rows.length;
-    }
-  }
-};
-const validateRow = (schema, table, document) => {
-  const definition = schema.tables[table];
-  if (!definition) {
-    return `unknown table: ${table}`;
-  }
-  for (const [field, validator] of Object.entries(definition.shape)) {
-    const candidate = document[field];
-    const optional = validator.kind === "optional";
-    if (candidate === void 0 && optional) {
-      continue;
-    }
-    const parser = validator.parse;
-    if (typeof parser !== "function") {
-      continue;
-    }
-    try {
-      parser(candidate);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return `field "${field}": ${message}`;
-    }
-  }
-  return void 0;
-};
-const explicitIdConflicts = async (writer, exec, table, explicitId) => {
-  try {
-    if (exec) {
-      const probe = await exec.all(`SELECT 1 AS hit FROM ${quoteIdentifier(table)} WHERE "id" = ? LIMIT 1`, [explicitId]);
-      return probe.length > 0;
-    }
-    const existing = await writer.get(explicitId);
-    return existing !== null;
-  } catch {
-    return false;
-  }
-};
-const importOneRow = async (writer, schema, args, row, line) => {
-  const { doc, table } = row;
-  if (schema.tables[table]?.shardMode?.kind !== "global") {
-    return { kind: "skip" };
-  }
-  if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
-    return { error: { code: "BAD_ROW", line, message: "row is missing or malformed `doc`", table }, kind: "error" };
-  }
-  const failure = validateRow(schema, table, doc);
-  if (failure !== void 0) {
-    return { error: { code: "VALIDATION_ERROR", line, message: failure, table }, kind: "error" };
-  }
-  const explicitId = typeof doc["_id"] === "string" ? doc["_id"] : void 0;
-  if (explicitId !== void 0 && await explicitIdConflicts(writer, args.exec, table, explicitId)) {
-    return { kind: "conflict" };
-  }
-  try {
-    await writer.insert(table, doc, { allowExplicitId: true });
-    return { inserted: table, kind: "inserted" };
-  } catch (error) {
-    const code = error.code ?? "INSERT_FAILED";
-    const message = error instanceof Error ? error.message : String(error);
-    return { error: { code, line, message, table }, kind: "error" };
-  }
-};
-const importGlobalRows = async (writer, schema, args) => {
-  const errors = [];
-  const inserted = {};
-  let conflicts = 0;
-  let line = (args.startLine ?? 1) - 1;
-  for (const row of args.rows) {
-    line += 1;
-    const outcome = await importOneRow(writer, schema, args, row, line);
-    switch (outcome.kind) {
-      case "conflict": {
-        conflicts += 1;
-        break;
-      }
-      case "error": {
-        errors.push(outcome.error);
-        break;
-      }
-      case "inserted": {
-        inserted[outcome.inserted] = (inserted[outcome.inserted] ?? 0) + 1;
-        break;
-      }
-    }
-  }
-  return { conflicts, errors, inserted };
-};
-
-export { exportGlobalRows, importGlobalRows, selectGlobalTables };

package/dist/packem_shared/facetGlobalColumn-C6u_WMIY.mjs

@@ -1,142 +0,0 @@
-import { runD1GlobalTableMigrations } from './createD1CtxDb-BMR8J0dT.mjs';
-import { decodeGlobalRow } from '@lunora/sql-store';
-
-const ensureGlobalTables = (exec, schema) => runD1GlobalTableMigrations(exec, schema);
-const DEFAULT_PAGE_SIZE = 50;
-const MAX_PAGE_SIZE = 500;
-const DEFAULT_FACET_LIMIT = 30;
-const MAX_FACET_LIMIT = 200;
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
-const INTERNAL_TABLE = /^sqlite_|^_cf_|^d1_|^__cdc|__agg_|__rank_|__fts_/u;
-const isInternalTable = (name) => INTERNAL_TABLE.test(name);
-const SENSITIVE_COLUMN = /password|secret|token|hash|salt|credential/iu;
-const listTableNames = async (exec) => {
-  const rows = await exec.all("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name", []);
-  return rows.map((row) => String(row["name"])).filter((name) => !isInternalTable(name));
-};
-const countRows = async (exec, quotedTable, whereSql = "", whereParams = []) => {
-  const rows = await exec.all(`SELECT COUNT(*) AS c FROM ${quotedTable}${whereSql}`, whereParams);
-  return Number(rows[0]?.["c"] ?? 0);
-};
-const physicalColumnName = (schema, table, displayColumn) => schema.tables[table] !== void 0 && displayColumn === "_id" ? "id" : displayColumn;
-const buildEqPredicate = (schema, table, displayColumns, filters) => {
-  if (filters === void 0 || filters.length === 0) {
-    return void 0;
-  }
-  const clauses = [];
-  const params = [];
-  for (const filter of filters) {
-    if (!displayColumns.includes(filter.column)) {
-      throw Object.assign(new Error(`unknown column: ${filter.column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
-    }
-    const quoted = quoteIdentifier(physicalColumnName(schema, table, filter.column));
-    if (filter.value === null || filter.value === void 0) {
-      clauses.push(`${quoted} IS NULL`);
-    } else {
-      clauses.push(`${quoted} = ?`);
-      params.push(filter.value);
-    }
-  }
-  return { params, where: clauses.join(" AND ") };
-};
-const decodeRow = (schema, table, row) => {
-  const definition = schema.tables[table];
-  if (definition) {
-    return decodeGlobalRow(definition, row);
-  }
-  const redacted = {};
-  for (const [key, value] of Object.entries(row)) {
-    redacted[key] = value !== null && value !== void 0 && SENSITIVE_COLUMN.test(key) ? "•••" : value;
-  }
-  return redacted;
-};
-const resolveColumns = async (exec, schema, table) => {
-  const definition = schema.tables[table];
-  if (definition) {
-    return ["_id", "_creationTime", ...Object.keys(definition.shape)];
-  }
-  const info = await exec.all(`PRAGMA table_info(${quoteIdentifier(table)})`, []);
-  return info.map((column) => String(column["name"]));
-};
-const resolveReferences = async (exec, schema, table) => {
-  if (schema.tables[table]) {
-    return void 0;
-  }
-  const rows = await exec.all(`PRAGMA foreign_key_list(${quoteIdentifier(table)})`, []);
-  if (rows.length === 0) {
-    return void 0;
-  }
-  const references = {};
-  for (const row of rows) {
-    const from = String(row["from"]);
-    const target = String(row["table"]);
-    references[from] ??= target;
-  }
-  return references;
-};
-const listGlobalTables = async (exec, schema) => {
-  await ensureGlobalTables(exec, schema);
-  const names = await listTableNames(exec);
-  return Promise.all(
-    names.map(async (name) => {
-      return { name, rowCount: await countRows(exec, quoteIdentifier(name)) };
-    })
-  );
-};
-const readGlobalTablePage = async (exec, schema, options) => {
-  const { table } = options;
-  await ensureGlobalTables(exec, schema);
-  const tableNames = await listTableNames(exec);
-  if (!tableNames.includes(table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
-  }
-  const limit = clamp(Math.trunc(options.limit ?? DEFAULT_PAGE_SIZE), 1, MAX_PAGE_SIZE);
-  const offset = Math.max(0, Math.trunc(options.offset ?? 0));
-  const quoted = quoteIdentifier(table);
-  const columns = await resolveColumns(exec, schema, table);
-  const predicate = buildEqPredicate(schema, table, columns, options.filters);
-  const whereSql = predicate === void 0 ? "" : ` WHERE ${predicate.where}`;
-  const whereParams = predicate?.params ?? [];
-  const total = await countRows(exec, quoted, whereSql, whereParams);
-  const raw = await exec.all(`SELECT * FROM ${quoted}${whereSql} LIMIT ? OFFSET ?`, [...whereParams, limit, offset]);
-  const rows = raw.map((row) => decodeRow(schema, table, row));
-  const references = await resolveReferences(exec, schema, table);
-  return references === void 0 ? { columns, rows, total } : { columns, refs: references, rows, total };
-};
-const facetGlobalColumn = async (exec, schema, options) => {
-  const { column, table } = options;
-  await ensureGlobalTables(exec, schema);
-  const tableNames = await listTableNames(exec);
-  if (!tableNames.includes(table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
-  }
-  const columns = await resolveColumns(exec, schema, table);
-  if (!columns.includes(column)) {
-    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
-  }
-  const quoted = quoteIdentifier(table);
-  const predicate = buildEqPredicate(schema, table, columns, options.filters);
-  const whereSql = predicate === void 0 ? "" : ` WHERE ${predicate.where}`;
-  const whereParams = predicate?.params ?? [];
-  if (schema.tables[table] === void 0 && SENSITIVE_COLUMN.test(column)) {
-    const total = await countRows(exec, quoted, whereSql, whereParams);
-    return { truncated: false, values: total === 0 ? [] : [{ count: total, value: "•••" }] };
-  }
-  const limit = clamp(Math.trunc(options.limit ?? DEFAULT_FACET_LIMIT), 1, MAX_FACET_LIMIT);
-  const physical = quoteIdentifier(physicalColumnName(schema, table, column));
-  const rows = await exec.all(`SELECT ${physical} AS value, COUNT(*) AS count FROM ${quoted}${whereSql} GROUP BY ${physical} ORDER BY count DESC LIMIT ?`, [
-    ...whereParams,
-    limit + 1
-  ]);
-  const truncated = rows.length > limit;
-  const kept = truncated ? rows.slice(0, limit) : rows;
-  return {
-    truncated,
-    values: kept.map((row) => {
-      return { count: Number(row["count"]), value: row["value"] };
-    })
-  };
-};
-
-export { facetGlobalColumn, listGlobalTables, readGlobalTablePage };

package/dist/packem_shared/sqliteDialect-DqYnHPuu.mjs

@@ -1,27 +0,0 @@
-import { sqliteEncode, sqliteDecode } from '@lunora/sql-store';
-import { sql } from 'drizzle-orm';
-import { sqlAffinityForKind } from '../dialect.mjs';
-
-const UNIQUE_VIOLATION_RE = /unique constraint failed/iu;
-const sqliteDialect = {
-  companionTypes: {
-    autoincrementPrimaryKey: "INTEGER PRIMARY KEY AUTOINCREMENT",
-    integer: "INTEGER",
-    key: "TEXT",
-    real: "REAL",
-    text: "TEXT"
-  },
-  columnType: (kind) => sqlAffinityForKind(kind),
-  decode: (value, kind) => sqliteDecode(value, kind),
-  encode: (value) => sqliteEncode(value),
-  frameworkColumns: () => [
-    { name: "id", type: "TEXT PRIMARY KEY" },
-    { name: "_creationTime", type: "REAL NOT NULL" }
-  ],
-  isUniqueViolation: (error) => error instanceof Error && UNIQUE_VIOLATION_RE.test(error.message),
-  name: "sqlite",
-  supportsReturning: true,
-  tableExists: (table) => sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${table}`
-};
-
-export { sqliteDialect as default };