@lunora/do 1.0.0-alpha.44 → 1.0.0-alpha.45

package/dist/packem_shared/exportShardRows-Dy3oFZ26.mjs

@@ -1,157 +0,0 @@
-import { toErrorBody } from '@lunora/errors';
-
-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 { body } = toErrorBody(error, { fallbackCode: "INSERT_FAILED" });
-    return { error: { code: body.code, line, message: body.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

@@ -1,20 +0,0 @@
-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/isSoftDeleted-CFJmhjFP.mjs

@@ -1,217 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { sql } from 'drizzle-orm';
-import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { runExternalSourceTick, materializeExternalRowsIncremental } from './materializeExternalRows-BtEGs1Fv.mjs';
-
-const SOURCE_CURSOR_TABLE = "__lunora_source_cursor";
-const serializeCursor = (value) => {
-  if (value instanceof Date) {
-    return `d:${value.toISOString()}`;
-  }
-  if (typeof value === "bigint") {
-    return `b:${value.toString()}`;
-  }
-  if (typeof value === "number") {
-    return `n:${value.toString()}`;
-  }
-  return `s:${value}`;
-};
-const deserializeCursor = (text) => {
-  const rest = text.slice(2);
-  switch (text[0]) {
-    case "b": {
-      return BigInt(rest);
-    }
-    case "d": {
-      return new Date(rest);
-    }
-    case "n": {
-      return Number(rest);
-    }
-    default: {
-      return rest;
-    }
-  }
-};
-const INTEGER_STRING = /^-?\d+$/;
-const DECIMAL_STRING = /^-?\d+(?:\.\d+)?$/;
-const cursorAfter = (a, b) => {
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() > b.getTime();
-  }
-  if (typeof a === "bigint" && typeof b === "bigint") {
-    return a > b;
-  }
-  if (typeof a === "number" && typeof b === "number") {
-    return a > b;
-  }
-  if (typeof a === "string" && typeof b === "string" && DECIMAL_STRING.test(a) && DECIMAL_STRING.test(b)) {
-    if (INTEGER_STRING.test(a) && INTEGER_STRING.test(b)) {
-      return BigInt(a) > BigInt(b);
-    }
-    return Number(a) > Number(b);
-  }
-  return String(a) > String(b);
-};
-const maxCursorValue = (rows, column, current) => {
-  let best = current === null ? void 0 : deserializeCursor(current);
-  for (const row of rows) {
-    const raw = row[column];
-    if (raw === null || raw === void 0) {
-      continue;
-    }
-    const value = raw;
-    if (best === void 0 || cursorAfter(value, best)) {
-      best = value;
-    }
-  }
-  return best === void 0 ? null : serializeCursor(best);
-};
-const migrateSourceCursor = (sql$1) => {
-  runDrizzle(
-    sql$1,
-    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(SOURCE_CURSOR_TABLE)} (
-            table_name TEXT NOT NULL,
-            shard_key TEXT NOT NULL,
-            watermark TEXT,
-            last_reconcile_ms INTEGER,
-            PRIMARY KEY (table_name, shard_key)
-        )`
-  );
-};
-const readSourceCursor = (sql$1, table, shardKey) => {
-  const rows = runDrizzle(
-    sql$1,
-    sql`SELECT watermark, last_reconcile_ms FROM ${sql.identifier(SOURCE_CURSOR_TABLE)} WHERE table_name = ${table} AND shard_key = ${shardKey} LIMIT 1`
-  ).toArray();
-  const row = rows[0];
-  return { lastReconcileMs: row?.last_reconcile_ms ?? null, watermark: row?.watermark ?? null };
-};
-const writeSourceCursor = (sql$1, table, shardKey, state) => {
-  runDrizzle(
-    sql$1,
-    sql`INSERT INTO ${sql.identifier(SOURCE_CURSOR_TABLE)} (table_name, shard_key, watermark, last_reconcile_ms)
-             VALUES (${table}, ${shardKey}, ${state.watermark}, ${state.lastReconcileMs})
-             ON CONFLICT(table_name, shard_key) DO UPDATE SET watermark = excluded.watermark, last_reconcile_ms = excluded.last_reconcile_ms`
-  );
-};
-
-const normalizeSourceValue = (value) => {
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "bigint") {
-    return String(value);
-  }
-  if (Array.isArray(value)) {
-    return value.map((element) => normalizeSourceValue(element));
-  }
-  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
-    return normalizeSourceDocument(value);
-  }
-  return value;
-};
-const normalizeSourceDocument = (document) => {
-  const normalized = {};
-  for (const [key, value] of Object.entries(document)) {
-    normalized[key] = normalizeSourceValue(value);
-  }
-  return normalized;
-};
-const liftSourceId = (row, options = {}) => {
-  const { idColumn = "id", map } = options;
-  const idValue = row[idColumn];
-  if (idValue === void 0 || idValue === null) {
-    throw new LunoraError("INTERNAL", `external-source: row is missing id column "${idColumn}"`);
-  }
-  if (typeof idValue !== "string" && typeof idValue !== "number" && typeof idValue !== "bigint") {
-    throw new TypeError(`external-source: id column "${idColumn}" must be a string or number`);
-  }
-  const id = String(idValue);
-  if (map) {
-    return normalizeSourceDocument({ ...map(row), _id: id });
-  }
-  const body = {};
-  for (const [key, value] of Object.entries(row)) {
-    if (key !== idColumn) {
-      body[key] = value;
-    }
-  }
-  return normalizeSourceDocument({ ...body, _id: id });
-};
-const isSourceDue = (refresh, lastPolledMs, nowMs) => {
-  if (refresh === "manual") {
-    return false;
-  }
-  if (refresh === void 0 || lastPolledMs === void 0) {
-    return true;
-  }
-  return nowMs - lastPolledMs >= refresh.everyMs;
-};
-const pullAndLift = async (client, query, parameters, source) => {
-  const rows = await client.query(query, parameters);
-  const documents = rows.map((row) => liftSourceId(row, { idColumn: source.idColumn, map: source.map }));
-  return { documents, rows };
-};
-const pullExternalSourceTick = async (sql, writer, client, table, source, shardKey) => {
-  const parameters = source.tenantBy ? source.tenantBy(shardKey) : [];
-  const { documents } = await pullAndLift(client, source.query, parameters, source);
-  return runExternalSourceTick(sql, writer, documents, { columns: source.columns, table });
-};
-const isSoftDeleted = (row, column) => {
-  const value = row[column];
-  return value !== null && value !== void 0 && value !== false && value !== 0;
-};
-const pullExternalSourceIncrementalTick = async (sql, writer, client, table, source, shardKey, nowMs) => {
-  const { cursor } = source;
-  if (!cursor) {
-    throw new LunoraError(
-      "INTERNAL",
-      `external-source: table "${table}" is mode "incremental" but has no \`cursor\` — this should have been rejected at defineSchema`
-    );
-  }
-  migrateSourceCursor(sql);
-  const state = readSourceCursor(sql, table, shardKey);
-  const tenantParameters = source.tenantBy ? source.tenantBy(shardKey) : [];
-  const reconcileDue = source.reconcileEveryMs !== void 0 && (state.lastReconcileMs === null || nowMs - state.lastReconcileMs >= source.reconcileEveryMs);
-  const fullPull = state.watermark === null || reconcileDue;
-  let slice;
-  let applied;
-  if (state.watermark === null || reconcileDue) {
-    slice = await pullAndLift(client, source.query, tenantParameters, source);
-    const { softDeleteColumn } = source;
-    const documents = softDeleteColumn ? slice.documents.filter((_document, index) => {
-      const row = slice.rows[index];
-      return !(row && isSoftDeleted(row, softDeleteColumn));
-    }) : slice.documents;
-    ({ applied } = await runExternalSourceTick(sql, writer, documents, { columns: source.columns, table }));
-  } else {
-    slice = await pullAndLift(client, cursor.query, [...tenantParameters, deserializeCursor(state.watermark)], source);
-    const { softDeleteColumn } = source;
-    const deletedIds = softDeleteColumn ? new Set(
-      slice.documents.flatMap((document, index) => {
-        const row = slice.rows[index];
-        return row && isSoftDeleted(row, softDeleteColumn) ? [String(document._id)] : [];
-      })
-    ) : void 0;
-    ({ applied } = await materializeExternalRowsIncremental(writer, slice.documents, { columns: source.columns, deletedIds, table }));
-  }
-  const watermark = maxCursorValue(slice.rows, cursor.column, state.watermark);
-  if (fullPull && watermark === null && slice.rows.length > 0) {
-    throw new LunoraError(
-      "INTERNAL",
-      `external-source: table "${table}" (mode "incremental") pulled ${String(slice.rows.length)} rows but none carry the cursor column "${cursor.column}" — the seed \`query\` must project it (matching \`cursor.query\`'s alias), or the watermark can never advance.`
-    );
-  }
-  const noRowCarriesCursor = slice.rows.length > 0 && slice.rows.every((row) => row[cursor.column] === null || row[cursor.column] === void 0);
-  if (!fullPull && noRowCarriesCursor) {
-    throw new LunoraError(
-      "INTERNAL",
-      `external-source: table "${table}" (mode "incremental") pulled ${String(slice.rows.length)} rows but none carry the cursor column "${cursor.column}" — \`cursor.query\` must project it (matching the seed \`query\`'s alias), or the watermark can never advance and every tick re-pulls the same stranded slice.`
-    );
-  }
-  writeSourceCursor(sql, table, shardKey, { lastReconcileMs: fullPull ? nowMs : state.lastReconcileMs, watermark });
-  return { applied };
-};
-
-export { isSoftDeleted, isSourceDue, liftSourceId, normalizeSourceValue, pullExternalSourceIncrementalTick, pullExternalSourceTick };

package/dist/packem_shared/json-response-BdbtpOhm.mjs

@@ -1,3 +0,0 @@
-const jsonResponse = (body, status = 200, headers) => Response.json(body, { headers: { "content-type": "application/json", ...headers }, status });
-
-export { jsonResponse as j };

package/dist/packem_shared/materializeExternalRows-BtEGs1Fv.mjs

@@ -1,45 +0,0 @@
-import { applyCdcChanges } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
-import { s as selectShapeRows } from './ctx-db-shapes-DTeFiHYS.mjs';
-import { diffExternalSource, projectExternalSourceRow } from './diffExternalSource-CovHfdyo.mjs';
-import { stableStringify } from './stableStringify-mC40mZts.mjs';
-
-const materializeExternalRows = async (writer, pulled, baseline, options) => {
-  const { changes, nextBaseline } = diffExternalSource(pulled, baseline, options);
-  await applyCdcChanges(writer, changes);
-  return { applied: changes.length, nextBaseline };
-};
-const materializeExternalRowsIncremental = async (writer, pulled, options) => {
-  const { columns, deletedIds, table } = options;
-  const changes = [];
-  for (const source of pulled) {
-    const value = projectExternalSourceRow(source, columns);
-    const id = String(value._id);
-    if (deletedIds?.has(id)) {
-      const existing = await writer.get(id, table);
-      if (existing) {
-        changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
-      }
-      continue;
-    }
-    const stored = await writer.get(id, table);
-    if (stored && stableStringify(projectExternalSourceRow({ ...stored, _id: id }, columns)) === stableStringify(value)) {
-      continue;
-    }
-    changes.push({ doc: value, id, op: "insert", seq: 0, table, ts: 0 });
-  }
-  await applyCdcChanges(writer, changes);
-  return { applied: changes.length };
-};
-const readExternalSourceBaseline = (sql, table, columns) => {
-  const baseline = /* @__PURE__ */ new Map();
-  for (const { doc, id } of selectShapeRows(sql, table, void 0)) {
-    baseline.set(id, stableStringify(projectExternalSourceRow({ ...doc, _id: id }, columns)));
-  }
-  return baseline;
-};
-const runExternalSourceTick = async (sql, writer, pulled, options) => {
-  const baseline = readExternalSourceBaseline(sql, options.table, options.columns);
-  return materializeExternalRows(writer, pulled, baseline, options);
-};
-
-export { materializeExternalRows, materializeExternalRowsIncremental, readExternalSourceBaseline, runExternalSourceTick };

package/dist/packem_shared/renderSql-D6eUcn2N.mjs

@@ -1,16 +0,0 @@
-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-BVax6rYu.mjs

@@ -1,120 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
-import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-uwOJxJJZ.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, g as geoTableName } from './do-sql-CGAgiQUz.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 migrateGeoIndexes = (sql$1, tableName, definition) => {
-  if (!definition.geoIndexes) {
-    return;
-  }
-  for (const index of definition.geoIndexes) {
-    const geoTable = geoTableName(tableName, index.name);
-    runDrizzle(
-      sql$1,
-      sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(geoTable)} (${sql.identifier("__id__")} TEXT PRIMARY KEY, ${sql.identifier("__geohash__")} TEXT NOT NULL, ${sql.identifier("__lat__")} REAL NOT NULL, ${sql.identifier("__lng__")} REAL NOT NULL)`
-    );
-    const btreeName = `${tableName}__geo_${index.name}__btree`;
-    runDrizzle(sql$1, createIndexSql(btreeName, geoTable, sql`${sql.identifier("__geohash__")} ASC, ${sql.identifier("__id__")} ASC`, false));
-  }
-};
-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);
-    migrateGeoIndexes(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 };