@lunora/d1 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/exportGlobalRows-BGCPm_nA.mjs

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,142 @@
+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

@@ -0,0 +1,27 @@
+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 };

package/package.json

@@ -1,31 +1,60 @@
 {
   "name": "@lunora/d1",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.2",
   "description": "D1 adapter for Lunora .global() tables, wrapping the Sessions API for read-your-writes",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "d1",
+    "durable-objects",
+    "lunora",
+    "migrations",
+    "sessions-api",
+    "sqlite",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/d1"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "d1",
-    "sessions-api",
-    "sqlite",
-    "migrations"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./dialect": {
+      "types": "./dist/dialect.d.ts",
+      "import": "./dist/dialect.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/do": "1.0.0-alpha.2",
+    "@lunora/sql-store": "1.0.0-alpha.2",
+    "drizzle-orm": "^0.45.2"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }