@lunora/do 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/ctx-db-idempotency-BdcNpvY4.mjs

@@ -0,0 +1,108 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+
+const CLIENT_WATERMARK_TABLE = "__client_watermark";
+const migrateClientWatermark = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CLIENT_WATERMARK_TABLE)} (
+            identity TEXT NOT NULL,
+            client_id TEXT NOT NULL,
+            last_mutation_id INTEGER NOT NULL,
+            PRIMARY KEY (identity, client_id)
+        )`
+  );
+};
+const readClientWatermark = (sql$1, identity, clientId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT last_mutation_id FROM ${sql.identifier(CLIENT_WATERMARK_TABLE)} WHERE identity = ${identity} AND client_id = ${clientId} LIMIT 1`
+  ).toArray();
+  return rows[0]?.last_mutation_id ?? 0;
+};
+const advanceClientWatermark = (sql$1, identity, clientId, mutationId) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(CLIENT_WATERMARK_TABLE)} (identity, client_id, last_mutation_id) VALUES (${identity}, ${clientId}, ${mutationId})
+             ON CONFLICT(identity, client_id) DO UPDATE SET last_mutation_id = MAX(last_mutation_id, excluded.last_mutation_id)`
+  );
+};
+
+const GLOBAL_SHAPE_SNAPSHOT_TABLE = "__global_shape_snapshot";
+const migrateGlobalShapeSnapshot = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (
+            connection_id TEXT NOT NULL,
+            sub_id TEXT NOT NULL,
+            members TEXT NOT NULL,
+            PRIMARY KEY (connection_id, sub_id)
+        )`
+  );
+};
+const readGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT members FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId} LIMIT 1`
+  ).toArray();
+  const raw = rows[0]?.members;
+  if (raw === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") {
+      return /* @__PURE__ */ new Map();
+    }
+    return new Map(Object.entries(parsed));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+};
+const writeGlobalShapeSnapshot = (sql$1, connectionId, subId, snapshot) => {
+  const members = JSON.stringify(Object.fromEntries(snapshot));
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (connection_id, sub_id, members) VALUES (${connectionId}, ${subId}, ${members})
+             ON CONFLICT(connection_id, sub_id) DO UPDATE SET members = excluded.members`
+  );
+};
+const deleteGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId}`);
+};
+const deleteGlobalShapeSnapshotsForConnection = (sql$1, connectionId) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId}`);
+};
+
+const IDEMPOTENCY_TABLE = "__idempotency";
+const migrateIdempotency = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(IDEMPOTENCY_TABLE)} (
+            identity TEXT NOT NULL,
+            mutation_id TEXT NOT NULL,
+            result_json TEXT NOT NULL,
+            ts REAL NOT NULL,
+            PRIMARY KEY (identity, mutation_id)
+        )`
+  );
+};
+const readIdempotent = (sql$1, identity, mutationId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT result_json, ts FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE identity = ${identity} AND mutation_id = ${mutationId} LIMIT 1`
+  ).toArray();
+  const row = rows[0];
+  return row === void 0 ? void 0 : { resultJson: row.result_json, ts: row.ts };
+};
+const writeIdempotent = (sql$1, identity, mutationId, resultJson, ts) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT OR IGNORE INTO ${sql.identifier(IDEMPOTENCY_TABLE)} (identity, mutation_id, result_json, ts) VALUES (${identity}, ${mutationId}, ${resultJson}, ${ts})`
+  );
+};
+const trimIdempotent = (sql$1, olderThanTs) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE ts < ${olderThanTs}`);
+};
+
+export { CLIENT_WATERMARK_TABLE as C, GLOBAL_SHAPE_SNAPSHOT_TABLE as G, IDEMPOTENCY_TABLE as I, migrateIdempotency as a, migrateGlobalShapeSnapshot as b, advanceClientWatermark as c, deleteGlobalShapeSnapshot as d, deleteGlobalShapeSnapshotsForConnection as e, readGlobalShapeSnapshot as f, readIdempotent as g, writeIdempotent as h, migrateClientWatermark as m, readClientWatermark as r, trimIdempotent as t, writeGlobalShapeSnapshot as w };

package/dist/packem_shared/ctx-db-shapes-DVoeZpo-.mjs

@@ -0,0 +1,53 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { D as DOC_COLUMN, r as rowToDocument, j as jsonPathSql } from './do-sql-BCHCWtrD.mjs';
+import { compileWhereSql } from './compileWhereSql-CXrhFA3G.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
+
+const shapeWhereStrategy = { fieldRef: jsonPathSql, serialize: serializeSqlValue };
+const idInClause = (ids) => {
+  if (ids.length === 0) {
+    return void 0;
+  }
+  return sql`id IN (${sql.join(
+    ids.map((id) => sql`${id}`),
+    sql`, `
+  )})`;
+};
+const composeWhere = (effectiveWhere, idRestriction) => {
+  const conditions = [];
+  if (idRestriction) {
+    conditions.push(idRestriction);
+  }
+  const compiled = compileWhereSql(effectiveWhere, shapeWhereStrategy);
+  if (compiled) {
+    conditions.push(compiled);
+  }
+  if (conditions.length === 0) {
+    return sql``;
+  }
+  return sql` WHERE ${sql.join(conditions, sql` AND `)}`;
+};
+const selectShapeRows = (sql$1, table, effectiveWhere) => {
+  const whereClause = composeWhere(effectiveWhere, void 0);
+  const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(table)}${whereClause}`).toArray();
+  const result = [];
+  for (const row of rows) {
+    const doc = rowToDocument(row);
+    const { id } = row;
+    if (doc !== void 0 && typeof id === "string") {
+      result.push({ doc, id });
+    }
+  }
+  return result;
+};
+const selectShapeMemberIds = (sql$1, table, effectiveWhere, ids) => {
+  if (ids.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const whereClause = composeWhere(effectiveWhere, idInClause(ids));
+  const rows = runDrizzle(sql$1, sql`SELECT id FROM ${sql.identifier(table)}${whereClause}`).toArray();
+  return new Set(rows.map((row) => row.id));
+};
+
+export { selectShapeRows as a, selectShapeMemberIds as s };

package/dist/packem_shared/do-exec-5eQy5cEi.mjs

@@ -0,0 +1,12 @@
+import { renderSql } from './renderSql-D6eUcn2N.mjs';
+
+const runSql = (sql, query, ...params) => {
+  const runner = sql.exec;
+  return runner.call(sql, query, ...params);
+};
+const runDrizzle = (exec, query) => {
+  const { params, sql: text } = renderSql("sqlite", query);
+  return runSql(exec, text, ...params);
+};
+
+export { runDrizzle as r };

package/dist/packem_shared/do-sql-BCHCWtrD.mjs

@@ -0,0 +1,87 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+
+const DOC_COLUMN = "__doc__";
+const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
+const jsonPath = (field) => {
+  if (field === "_id" || field === "id") {
+    return "id";
+  }
+  if (field === "_creationTime") {
+    return "_creationTime";
+  }
+  return `json_extract(${DOC_COLUMN}, '$.${field.replaceAll("'", "''")}')`;
+};
+const jsonPathSql = (field) => sql.raw(jsonPath(field));
+const qualifiedJsonPath = (table, field) => {
+  const qualified = quoteIdentifier(table);
+  if (field === "_id" || field === "id") {
+    return `${qualified}.id`;
+  }
+  if (field === "_creationTime") {
+    return `${qualified}._creationTime`;
+  }
+  return `json_extract(${qualified}.${DOC_COLUMN}, '$.${field.replaceAll("'", "''")}')`;
+};
+const qualifiedJsonPathSql = (table, field) => sql.raw(qualifiedJsonPath(table, field));
+const createIndexSql = (name, table, columns, unique) => sql`CREATE ${unique ? sql`UNIQUE ` : sql``}INDEX IF NOT EXISTS ${sql.identifier(name)} ON ${sql.identifier(table)} (${columns})`;
+const AGG_KEY = sql.identifier("__key__");
+const AGG_VALUE = sql.identifier("__value__");
+const AGG_COUNT = sql.identifier("__count__");
+const aggUpsertSql = (aggTable, key, value, count, set) => sql`INSERT INTO ${sql.identifier(aggTable)} (${AGG_KEY}, ${AGG_VALUE}, ${AGG_COUNT}) VALUES (${key}, ${value}, ${count}) ON CONFLICT(${AGG_KEY}) DO UPDATE SET ${set}`;
+const tableColumns = (definition) => {
+  const columns = [];
+  for (const [field, validator] of Object.entries(definition.shape)) {
+    const column = validator._meta?.column;
+    if (column) {
+      columns.push([field, column]);
+    }
+  }
+  return columns;
+};
+const rowToDocument = (row) => {
+  if (!row) {
+    return void 0;
+  }
+  const raw = row[DOC_COLUMN];
+  let parsed;
+  if (typeof raw === "string") {
+    parsed = JSON.parse(raw);
+  } else if (raw && typeof raw === "object") {
+    parsed = raw;
+  } else {
+    parsed = {};
+  }
+  const { id } = row;
+  if (typeof id === "string") {
+    parsed["_id"] = id;
+  }
+  const creationTime = row["_creationTime"];
+  if (typeof creationTime === "number") {
+    parsed["_creationTime"] = creationTime;
+  }
+  return parsed;
+};
+const ftsAvailabilityCache = /* @__PURE__ */ new WeakMap();
+const isFtsAvailable = (sql$1) => {
+  const cached = ftsAvailabilityCache.get(sql$1);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let available;
+  try {
+    runDrizzle(sql$1, sql`CREATE VIRTUAL TABLE IF NOT EXISTS ${sql.identifier("__lunora_fts_probe")} USING fts5(x)`);
+    available = true;
+  } catch {
+    available = false;
+  } finally {
+    try {
+      runDrizzle(sql$1, sql`DROP TABLE IF EXISTS ${sql.identifier("__lunora_fts_probe")}`);
+    } catch {
+    }
+  }
+  ftsAvailabilityCache.set(sql$1, available);
+  return available;
+};
+
+export { AGG_KEY as A, DOC_COLUMN as D, AGG_VALUE as a, AGG_COUNT as b, createIndexSql as c, aggUpsertSql as d, qualifiedJsonPathSql as e, isFtsAvailable as i, jsonPathSql as j, quoteIdentifier as q, rowToDocument as r, tableColumns as t };

package/dist/packem_shared/exportShardRows-DZEhUeyI.mjs

@@ -0,0 +1,156 @@
+const DEFAULT_BATCH_SIZE = 200;
+const selectExportTables = (schema, requested) => {
+  const isShardLocal = (table) => {
+    const definition = schema.tables[table];
+    if (!definition) {
+      return false;
+    }
+    return definition.shardMode?.kind !== "global";
+  };
+  if (requested && requested.length > 0) {
+    const filtered = [];
+    for (const name of requested) {
+      if (isShardLocal(name)) {
+        filtered.push(name);
+      }
+    }
+    return filtered;
+  }
+  const result = [];
+  for (const name of Object.keys(schema.tables)) {
+    if (isShardLocal(name)) {
+      result.push(name);
+    }
+  }
+  return result;
+};
+const exportShardTable = async function* (writer, table, batchSize = DEFAULT_BATCH_SIZE) {
+  let cursor = null;
+  let done = false;
+  while (!done) {
+    const page = await writer.findMany(table, { cursor, limit: batchSize });
+    for (const record of page.page) {
+      yield { doc: record, table };
+    }
+    cursor = page.continueCursor;
+    done = page.isDone || cursor === null;
+  }
+};
+const exportShardRows = async function* (writer, schema, args) {
+  const tables = selectExportTables(schema, args.tables);
+  const batchSize = args.batchSize ?? DEFAULT_BATCH_SIZE;
+  for (const table of tables) {
+    yield* exportShardTable(writer, table, batchSize);
+  }
+};
+const FRAMEWORK_FIELDS = /* @__PURE__ */ new Set(["_creationTime", "_id"]);
+const validateAgainstShape = (definition, payload) => {
+  for (const [field, validator] of Object.entries(definition.shape)) {
+    const candidate = payload[field];
+    if (candidate === void 0 && validator.kind === "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 validateImportRow = (schema, table, record) => {
+  const definition = schema.tables[table];
+  if (!definition) {
+    return `unknown table: ${table}`;
+  }
+  if (definition.shardMode?.kind === "global") {
+    return `table "${table}" is a global (.global()) table and is not importable through the shard import path`;
+  }
+  const payload = Object.fromEntries(Object.entries(record).filter(([key]) => !FRAMEWORK_FIELDS.has(key)));
+  for (const key of Object.keys(payload)) {
+    if (!(key in definition.shape)) {
+      return `unexpected field "${key}": not declared in table "${table}"`;
+    }
+  }
+  return validateAgainstShape(definition, payload);
+};
+const idAlreadyExists = async (writer, explicitId) => {
+  try {
+    const existing = await writer.get(explicitId);
+    return existing !== null;
+  } catch {
+    return false;
+  }
+};
+const importOneRow = async (writer, schema, row, line) => {
+  const { doc, table } = row;
+  if (typeof table !== "string" || table.length === 0) {
+    return { error: { code: "BAD_ROW", line, message: "row is missing `table`", table }, kind: "error" };
+  }
+  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 = validateImportRow(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 idAlreadyExists(writer, explicitId)) {
+    return { kind: "conflict" };
+  }
+  try {
+    await writer.insert(table, doc, { allowExplicitId: true });
+    return { kind: "inserted", table };
+  } 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 importShardRows = 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, row, line);
+    if (outcome.kind === "error") {
+      errors.push(outcome.error);
+    } else if (outcome.kind === "conflict") {
+      conflicts += 1;
+    } else {
+      inserted[outcome.table] = (inserted[outcome.table] ?? 0) + 1;
+    }
+  }
+  return { conflicts, errors, inserted };
+};
+const parseExportShardArgs = (args) => {
+  const tables = Array.isArray(args["tables"]) ? args["tables"].filter((entry) => typeof entry === "string") : void 0;
+  const batchSize = typeof args["batchSize"] === "number" ? args["batchSize"] : void 0;
+  return { batchSize, tables };
+};
+const parseImportShardArgs = (args) => {
+  const rawRows = Array.isArray(args["rows"]) ? args["rows"] : [];
+  const rows = [];
+  for (const entry of rawRows) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const candidate = entry;
+    if (typeof candidate.table !== "string" || !candidate.doc || typeof candidate.doc !== "object" || Array.isArray(candidate.doc)) {
+      rows.push({ doc: candidate.doc ?? {}, table: typeof candidate.table === "string" ? candidate.table : "" });
+      continue;
+    }
+    rows.push({ doc: candidate.doc, table: candidate.table });
+  }
+  const startLine = typeof args["startLine"] === "number" ? args["startLine"] : void 0;
+  return { rows, startLine };
+};
+
+export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow };

package/dist/packem_shared/hasTrigger-5N6_Fx0A.mjs

@@ -0,0 +1,20 @@
+const runTriggers = async (options) => {
+  const definitions = options.schema.tables[options.tableName]?.triggerMap;
+  if (!definitions) {
+    return;
+  }
+  for (const definition of Object.values(definitions)) {
+    if (definition.timing === options.timing && definition.op === options.op) {
+      await definition.handler(options.ctx, options.event);
+    }
+  }
+};
+const hasTrigger = (schema, tableName, op) => {
+  const definitions = schema.tables[tableName]?.triggerMap;
+  if (!definitions) {
+    return false;
+  }
+  return Object.values(definitions).some((definition) => definition.op === op);
+};
+
+export { hasTrigger, runTriggers };

package/dist/packem_shared/renderSql-D6eUcn2N.mjs

@@ -0,0 +1,16 @@
+import { sql } from 'drizzle-orm';
+import { MySqlDialect } from 'drizzle-orm/mysql-core';
+import { PgDialect } from 'drizzle-orm/pg-core';
+import { SQLiteSyncDialect } from 'drizzle-orm/sqlite-core';
+
+const PG_DIALECT = new PgDialect();
+const MYSQL_DIALECT = new MySqlDialect();
+const SQLITE_DIALECT = new SQLiteSyncDialect();
+const DIALECTS = { mysql: MYSQL_DIALECT, postgres: PG_DIALECT, sqlite: SQLITE_DIALECT };
+const renderSql = (engine, query) => {
+  const { params, sql: text } = DIALECTS[engine].sqlToQuery(query);
+  return { params, sql: text };
+};
+const param = (value) => sql`${value}`;
+
+export { param, renderSql };

package/dist/packem_shared/runShardMigrations-nIwoQeOK.mjs

@@ -0,0 +1,105 @@
+import { sql } from 'drizzle-orm';
+import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
+import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+import { m as migrateClientWatermark, a as migrateIdempotency, b as migrateGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { D as DOC_COLUMN, j as jsonPathSql, c as createIndexSql, t as tableColumns, i as isFtsAvailable, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';
+import { sortColumnName, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { ftsTableName } from './buildFtsMatch-BLEMawrp.mjs';
+
+const migrateSecondaryIndexes = (sql$1, tableName, definition) => {
+  for (const index of definition.indexes) {
+    const indexName = `${tableName}_${index.name}`;
+    const expressions = sql.join(
+      index.fields.map((field) => jsonPathSql(field)),
+      sql`, `
+    );
+    runDrizzle(sql$1, createIndexSql(indexName, tableName, expressions, index.unique ?? false));
+  }
+  for (const [field, column] of tableColumns(definition)) {
+    if (!column.unique) {
+      continue;
+    }
+    const indexName = `${tableName}_unique_${field}`;
+    runDrizzle(sql$1, createIndexSql(indexName, tableName, jsonPathSql(field), true));
+  }
+};
+const migrateSearchIndexes = (sql$1, tableName, definition) => {
+  if (!definition.searchIndexes || definition.searchIndexes.length === 0 || !isFtsAvailable(sql$1)) {
+    return;
+  }
+  for (const index of definition.searchIndexes) {
+    const ftName = ftsTableName(tableName, index.name);
+    runDrizzle(
+      sql$1,
+      sql`CREATE VIRTUAL TABLE IF NOT EXISTS ${sql.identifier(ftName)} USING fts5(${sql.identifier("__text__")}, ${sql.identifier("__id__")} UNINDEXED)`
+    );
+  }
+};
+const migrateAggregateIndexes = (sql$1, tableName, definition) => {
+  if (!definition.aggregateIndexes) {
+    return;
+  }
+  for (const index of definition.aggregateIndexes) {
+    const aggTable = aggregateTableName(tableName, index.name);
+    runDrizzle(
+      sql$1,
+      sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(aggTable)} (${AGG_KEY} TEXT PRIMARY KEY, ${AGG_VALUE} REAL, ${AGG_COUNT} INTEGER NOT NULL DEFAULT 0)`
+    );
+    const columns = runDrizzle(sql$1, sql`PRAGMA table_info(${sql.identifier(aggTable)})`).toArray();
+    if (!columns.some((column) => column.name === "__count__")) {
+      runDrizzle(sql$1, sql`ALTER TABLE ${sql.identifier(aggTable)} ADD COLUMN ${AGG_COUNT} INTEGER NOT NULL DEFAULT 0`);
+    }
+  }
+};
+const migrateRankIndexes = (sql$1, tableName, definition) => {
+  if (!definition.rankIndexes) {
+    return;
+  }
+  for (const index of definition.rankIndexes) {
+    const rankTable = rankTableName(tableName, index.name);
+    const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+    const columnDdls = sortColumns.map((column) => sql`${sql.identifier(column)} BLOB`);
+    const columnPart = columnDdls.length > 0 ? sql`, ${sql.join(columnDdls, sql`, `)}` : sql``;
+    runDrizzle(
+      sql$1,
+      sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(rankTable)} (${sql.identifier("__id__")} TEXT PRIMARY KEY, ${sql.identifier("__partition__")} TEXT NOT NULL${columnPart})`
+    );
+    const orderedColumns = [sql`${sql.identifier("__partition__")} ASC`];
+    for (const [i, column] of sortColumns.entries()) {
+      const direction = index.sortBy[i]?.direction;
+      orderedColumns.push(sql`${sql.identifier(column)} ${sql.raw(direction === "desc" ? "DESC" : "ASC")}`);
+    }
+    orderedColumns.push(sql`${sql.identifier("__id__")} ASC`);
+    const btreeName = `${tableName}__rank_${index.name}__btree`;
+    runDrizzle(sql$1, createIndexSql(btreeName, rankTable, sql.join(orderedColumns, sql`, `), false));
+  }
+};
+const runShardMigrations = (sql$1, schema, options = {}) => {
+  for (const [tableName, definition] of Object.entries(schema.tables)) {
+    if (definition.shardMode?.kind === "global") {
+      continue;
+    }
+    runDrizzle(
+      sql$1,
+      sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(tableName)} (
+                id TEXT PRIMARY KEY,
+                _creationTime REAL NOT NULL,
+                ${sql.identifier(DOC_COLUMN)} TEXT NOT NULL
+            )`
+    );
+    migrateSecondaryIndexes(sql$1, tableName, definition);
+    migrateSearchIndexes(sql$1, tableName, definition);
+    migrateAggregateIndexes(sql$1, tableName, definition);
+    migrateRankIndexes(sql$1, tableName, definition);
+  }
+  if (options.cdc) {
+    migrateCdcLog(sql$1);
+    migrateCdcMeta(sql$1);
+    migrateClientWatermark(sql$1);
+  }
+  migrateIdempotency(sql$1);
+  migrateGlobalShapeSnapshot(sql$1);
+};
+
+export { runShardMigrations };