@lunora/do 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/packem_shared/{assertValidClientId-CBZ1zC96.mjs → NotUniqueError-h_thNFSZ.mjs}

@@ -1,27 +1,27 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './matchesStaticWhere-CFk6adSu.mjs';
+import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName, coerceAggregateNumber, readAggregateValue } from './aggregateTableName-CxNqY1Sl.mjs';
 import { mergeWhere, CountRlsUnsupportedError, selectIndexForGroupBy, selectIndexForCount, selectIndexForAggregate } from './CountRlsUnsupportedError-28ZvvwKS.mjs';
-import { appendCdcChange } from './applyCdcChanges-Ctdmxmrv.mjs';
-export { CDC_LOG_TABLE, CDC_META_TABLE, applyCdcChanges, bumpCdcEpoch, migrateCdcLog, migrateCdcMeta, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './applyCdcChanges-Ctdmxmrv.mjs';
+import { appendCdcChange } from './CDC_LOG_TABLE-Ctdmxmrv.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, bumpCdcEpoch, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './CDC_LOG_TABLE-Ctdmxmrv.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { i as isFtsAvailable, D as DOC_COLUMN$1, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT, d as aggUpsertSql, j as jsonPathSql, q as quoteIdentifier, t as tableColumns, e as qualifiedJsonPathSql } from './do-sql-BCHCWtrD.mjs';
 import { param } from './renderSql-D6eUcn2N.mjs';
 import { s as sortColumnName, m as matchesRankStaticWhere, e as encodePartitionKey, b as serializeSqlValue, r as rankTableName, a as resolveRankPartition, R as RANK_TIEBREAK } from './rank-CrkEIpF4.mjs';
-import { stringifySearchText, ftsTableName, tokenizeSearch, buildFtsMatch, scoreDocument } from './ftsTableName-BLEMawrp.mjs';
+import { stringifySearchText, ftsTableName, tokenizeSearch, buildFtsMatch, scoreDocument } from './buildFtsMatch-BLEMawrp.mjs';
 import { SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
-import { decodeCursor, normalizeOrderKeys, buildSeekWhere, encodeCursor, buildSeekBeforeWhere } from './buildSeekWhere-lVsNXSLy.mjs';
+import { decodeCursor, normalizeOrderKeys, buildSeekWhere, applySelect, encodeCursor, softDeleteScope, buildSeekBeforeWhere } from './applySelect-BvZdFUBT.mjs';
 import NotFoundError from './NotFoundError-CMuMZt81.mjs';
-import { assertFlatPredicate, resolveRelationPredicates } from './assertFlatPredicate-DyVYReuT.mjs';
-import { runRowValidators, resolveWith, applyOnDelete } from './applyOnDelete-CMif2RKw.mjs';
-import { guardWriter } from './guardWriter-u3UlnCH5.mjs';
+import { assertFlatPredicate, resolveRelationPredicates } from './DEFAULT_MAX_RELATION_KEYS-Dou2PWdO.mjs';
+import { runRowValidators, resolveWith, applyOnDelete } from './applyOnDelete-sA7o1CqD.mjs';
+import { guardWriter } from './RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs';
 import { createSystemReader } from './createSystemReader-8CzSZP9V.mjs';
 import { ConflictError } from './ConflictError-C0STs6bU.mjs';
-import { runTriggers } from './runTriggers-5N6_Fx0A.mjs';
+import { runTriggers } from './hasTrigger-5N6_Fx0A.mjs';
 import { compileWhereSql } from './compileWhereSql-CXrhFA3G.mjs';
-export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-BF5eL7kW.mjs';
-export { I as IDEMPOTENCY_TABLE, m as migrateIdempotency, r as readIdempotent, t as trimIdempotent, w as writeIdempotent } from './ctx-db-idempotency-DkC9rP91.mjs';
-export { runShardMigrations } from './runShardMigrations-C3bn5r93.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-BbVPvciS.mjs';
+export { I as IDEMPOTENCY_TABLE, r as readIdempotent, t as trimIdempotent, w as writeIdempotent } from './ctx-db-idempotency-DkC9rP91.mjs';
+export { runShardMigrations } from './runShardMigrations-PabobOjF.mjs';
 
 const rankIndexFieldsUnchanged = (index, previous, next) => {
   const fields = [...index.partitionBy ?? [], ...index.sortBy.map((key) => key.field), ...index.where ? Object.keys(index.where) : []];
@@ -534,7 +534,7 @@ const createSearchBuilder = (search, tableName) => {
   };
   return builder;
 };
-const searchViaFts = (sql$1, tableName, search, limit) => {
+const searchViaFts = (sql$1, tableName, search, limit, scopeCondition) => {
   const tokens = tokenizeSearch(search.query);
   if (tokens.length === 0) {
     return [];
@@ -544,6 +544,9 @@ const searchViaFts = (sql$1, tableName, search, limit) => {
   for (const filter of search.filters) {
     whereClauses.push(sql`${jsonPathSql(filter.field)} = ${serializeSqlValue(filter.value)}`);
   }
+  if (scopeCondition) {
+    whereClauses.push(scopeCondition);
+  }
   let query = sql`SELECT m.id, m._creationTime, m.${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(ftName)} f JOIN ${sql.identifier(tableName)} m ON m.id = f.${sql.identifier("__id__")} WHERE ${sql.join(whereClauses, sql` AND `)} ORDER BY f.rank, m._creationTime DESC`;
   if (typeof limit === "number") {
     query = sql`${query} LIMIT ${sql.raw(String(Math.max(0, Math.floor(limit))))}`;
@@ -558,7 +561,7 @@ const searchViaFts = (sql$1, tableName, search, limit) => {
   }
   return docs;
 };
-const searchViaScan = (sql$1, tableName, search, limit) => {
+const searchViaScan = (sql$1, tableName, search, limit, scopeCondition) => {
   const tokens = tokenizeSearch(search.query);
   if (tokens.length === 0) {
     return [];
@@ -567,6 +570,9 @@ const searchViaScan = (sql$1, tableName, search, limit) => {
   for (const filter of search.filters) {
     whereClauses.push(sql`${jsonPathSql(filter.field)} = ${serializeSqlValue(filter.value)}`);
   }
+  if (scopeCondition) {
+    whereClauses.push(scopeCondition);
+  }
   let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
   if (whereClauses.length > 0) {
     query = sql`${query} WHERE ${sql.join(whereClauses, sql` AND `)}`;
@@ -660,11 +666,12 @@ const scanDocs = (rows, filters, cap) => {
   }
   return docs;
 };
-const paginateStage = (sql$1, tableName, stage, options) => {
+const paginateStage = (sql$1, tableName, stage, options, scopeCondition) => {
   const numberItems = Math.max(0, Math.floor(options.numItems));
   const orderKeys = paginateOrderKeys(stage);
   const bounded = typeof options.endCursor === "string";
-  const whereCondition = compileWhereSql(paginateWhere(stage, orderKeys, options.cursor, options.endCursor), doWhereSqlStrategy);
+  const pageWhere = compileWhereSql(paginateWhere(stage, orderKeys, options.cursor, options.endCursor), doWhereSqlStrategy);
+  const whereCondition = scopeCondition && pageWhere ? sql`${pageWhere} AND ${scopeCondition}` : scopeCondition ?? pageWhere;
   let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
   if (whereCondition) {
     query = sql`${query} WHERE ${whereCondition}`;
@@ -721,6 +728,8 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
   if (!tableDefinition) {
     throw new Error(`unknown table: ${tableName}`);
   }
+  const scopeWhere = softDeleteScope(tableDefinition.softDeleteMode, void 0);
+  const scopeCondition = scopeWhere ? compileWhereSql(scopeWhere, doWhereSqlStrategy) : void 0;
   const stage = {
     indexFields: [],
     indexName: void 0,
@@ -735,7 +744,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     }
     const filtered = stage.inMemoryFilters.length > 0;
     const engineLimit = filtered ? void 0 : limit;
-    const docs = isFtsAvailable(sql$1) ? searchViaFts(sql$1, tableName, search, engineLimit) : searchViaScan(sql$1, tableName, search, engineLimit);
+    const docs = isFtsAvailable(sql$1) ? searchViaFts(sql$1, tableName, search, engineLimit, scopeCondition) : searchViaScan(sql$1, tableName, search, engineLimit, scopeCondition);
     if (!filtered) {
       return docs;
     }
@@ -766,6 +775,9 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     for (const condition of stage.sqlConditions) {
       whereClauses.push(sql`${jsonPathSql(condition.field)} ${sql.raw(condition.comparator)} ${serializeSqlValue(condition.value)}`);
     }
+    if (scopeCondition) {
+      whereClauses.push(scopeCondition);
+    }
     let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
     if (whereClauses.length > 0) {
       query = sql`${query} WHERE ${sql.join(whereClauses, sql` AND `)}`;
@@ -813,7 +825,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
       if (stage.search) {
         throw new Error("pagination is not supported on search queries; use .take(n) or .collect()");
       }
-      return paginateStage(sql$1, tableName, stage, options);
+      return paginateStage(sql$1, tableName, stage, options, scopeCondition);
     },
     // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
     async take(limit) {
@@ -1130,10 +1142,11 @@ const createShardCtxDb = (options) => {
         throw new Error(`aggregate(${tableName}, { op: "${aggOptions.op}" }): "field" is required for non-count reducers`);
       }
       onRead(tableName, SCAN_DEP);
-      const effective = mergeWhere(aggOptions.baseWhere, aggOptions.where);
+      const aggScope = softDeleteScope(definition.softDeleteMode, void 0);
+      const effective = mergeWhere(mergeWhere(aggOptions.baseWhere, aggOptions.where), aggScope);
       const resolved = await resolveAggregateRelations(effective, tableName, aggOptions.relationBaseWhere);
       const hasRelation = resolved !== effective;
-      if (definition.aggregateIndexes && !aggOptions.baseWhere && !hasRelation) {
+      if (definition.aggregateIndexes && !aggOptions.baseWhere && !hasRelation && !aggScope) {
         const planned = selectIndexForAggregate(definition.aggregateIndexes, aggOptions.op, aggOptions.field, aggOptions.where);
         if (planned) {
           ensureBackfilled(tableName, planned.index);
@@ -1175,10 +1188,11 @@ const createShardCtxDb = (options) => {
         throw new CountRlsUnsupportedError(tableName);
       }
       onRead(tableName, SCAN_DEP);
-      const effective = mergeWhere(countOptions.baseWhere, countOptions.where);
+      const countScope = softDeleteScope(definition.softDeleteMode, void 0);
+      const effective = mergeWhere(mergeWhere(countOptions.baseWhere, countOptions.where), countScope);
       const resolved = await resolveAggregateRelations(effective, tableName, countOptions.relationBaseWhere);
       const hasRelation = resolved !== effective;
-      if (definition.aggregateIndexes && !countOptions.baseWhere && !hasRelation) {
+      if (definition.aggregateIndexes && !countOptions.baseWhere && !hasRelation && !countScope) {
         const planned = selectIndexForCount(definition.aggregateIndexes, countOptions.where);
         if (planned) {
           ensureBackfilled(tableName, planned.index);
@@ -1199,16 +1213,22 @@ const createShardCtxDb = (options) => {
       const row = runDrizzle(sql$1, query).one();
       return row.count;
     },
-    async delete(id, expectedTable) {
+    async delete(id, expectedTable, deleteOptions) {
       const located = locateRowById(id, expectedTable);
       if (!located) {
         const global = expectedTable === void 0 ? globalFallback() : void 0;
         if (global) {
-          await global.delete(id);
+          await global.delete(id, void 0, deleteOptions);
         }
         return;
       }
       const { docJson: existingJson, row: existing, tableName } = located;
+      const definition = schema.tables[tableName];
+      const hard = deleteOptions?.hard === true;
+      const softField = !hard && definition?.softDeleteMode ? definition.softDeleteMode.field : void 0;
+      if (softField && existing[softField] !== null && existing[softField] !== void 0) {
+        return;
+      }
       if (hasMatchingTrigger(tableName, "before", "delete")) {
         await fireTriggers("before", "delete", { id, op: "delete", previous: existing, table: tableName });
       }
@@ -1216,10 +1236,10 @@ const createShardCtxDb = (options) => {
         deletedId: id,
         deletedReference: (references) => existing[references],
         findHolders: async (holderTable, field, value) => {
-          const holders = await routeForHolder(holderTable).findMany(holderTable, { where: { [field]: value } });
+          const holders = await routeForHolder(holderTable).findMany(holderTable, { includeDeleted: hard, where: { [field]: value } });
           return holders.page;
         },
-        onCascade: (holderTable, holderId) => routeForHolder(holderTable).delete(holderId),
+        onCascade: (holderTable, holderId) => routeForHolder(holderTable).delete(holderId, void 0, deleteOptions),
         onRestrict: (message) => {
           throw new ConflictError(message, "restrict");
         },
@@ -1230,6 +1250,25 @@ const createShardCtxDb = (options) => {
       });
       ensureBackfilledForTable(tableName);
       ensureRankBackfilledForTable(tableName);
+      if (softField) {
+        const merged = { ...existing, [softField]: clock(), _id: id };
+        runGuardedWrite(
+          sql$1,
+          tableName,
+          sql`UPDATE ${sql.identifier(tableName)} SET ${sql.identifier(DOC_COLUMN$1)} = ${JSON.stringify(merged)} WHERE id = ${id} AND ${sql.identifier(DOC_COLUMN$1)} = ${existingJson}`
+        );
+        syncSearch(tableName, id, merged);
+        syncAggregates(tableName, existing, merged);
+        syncRanks(tableName, id, existing, void 0);
+        cache?.invalidate(tableName, id);
+        recordCdc(tableName, id, "update", merged);
+        broadcast({ key: id, op: "update", row: merged, table: tableName });
+        if (hasMatchingTrigger(tableName, "after", "delete")) {
+          await fireTriggers("after", "delete", { id, op: "delete", previous: existing, table: tableName });
+        }
+        await onWrite({ id, op: "delete", table: tableName });
+        return;
+      }
       runGuardedWrite(
         sql$1,
         tableName,
@@ -1271,7 +1310,8 @@ const createShardCtxDb = (options) => {
         onRead(tableName, SCAN_DEP);
         return global.findMany(tableName, args);
       }
-      if (!schema.tables[tableName]) {
+      const findManyDefinition = schema.tables[tableName];
+      if (!findManyDefinition) {
         throw new Error(`unknown table: ${tableName}`);
       }
       const isFullScan = !args.where && !args.baseWhere;
@@ -1283,6 +1323,7 @@ const createShardCtxDb = (options) => {
       const orderKeys = normalizeOrderKeys(args.orderBy);
       const seek = args.cursor ? buildSeekWhere(orderKeys, decodeCursor(args.cursor)) : void 0;
       let predicate = mergeWhere(args.baseWhere, args.where);
+      predicate = mergeWhere(predicate, softDeleteScope(findManyDefinition.softDeleteMode, args.includeDeleted));
       predicate = await resolveRelationPredicates(predicate, {
         canPushExists: relationExistsPushDownEnabled ? canPushRelationExists : void 0,
         existsPushMode: relationExistsPushDown === "always" ? "always" : "auto",
@@ -1329,7 +1370,7 @@ const createShardCtxDb = (options) => {
             with: args.with
           });
         }
-        return { continueCursor: null, isDone: true, page: docs };
+        return { continueCursor: null, isDone: true, page: applySelect(docs, args.select, args.with) };
       }
       const hasMore = docs.length > limit;
       const page = hasMore ? docs.slice(0, limit) : docs;
@@ -1346,10 +1387,12 @@ const createShardCtxDb = (options) => {
         });
       }
       return {
+        // The cursor is encoded from `last` (the full, unprojected row) above,
+        // so `applySelect` only trims the returned payload — paging is intact.
         // eslint-disable-next-line unicorn/no-null -- QueryPage.continueCursor is `null | string`: null is the documented "no further page" cursor on the wire
         continueCursor: hasMore && last ? encodeCursor(last, orderKeys) : null,
         isDone: !hasMore,
-        page
+        page: applySelect(page, args.select, args.with)
       };
     },
     async get(id, expectedTable) {
@@ -1390,10 +1433,11 @@ const createShardCtxDb = (options) => {
       if (agg.op !== "count" && !agg.field) {
         throw new Error(`groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
       }
-      const effective = mergeWhere(groupOptions.baseWhere, groupOptions.where);
+      const groupScope = softDeleteScope(definition.softDeleteMode, void 0);
+      const effective = mergeWhere(mergeWhere(groupOptions.baseWhere, groupOptions.where), groupScope);
       const resolved = await resolveAggregateRelations(effective, tableName, groupOptions.relationBaseWhere);
       const hasRelation = resolved !== effective;
-      if (definition.aggregateIndexes && !groupOptions.baseWhere && !hasRelation) {
+      if (definition.aggregateIndexes && !groupOptions.baseWhere && !hasRelation && !groupScope) {
         const planned = selectIndexForGroupBy(definition.aggregateIndexes, agg.op, agg.field, groupOptions.by, groupOptions.where);
         if (planned) {
           ensureBackfilled(tableName, planned.index);
@@ -1696,6 +1740,26 @@ const createShardCtxDb = (options) => {
       const { directions, hasMore, rows } = computeRankPage(rankPageDeps, tableName, indexName, rankPageOptions);
       return { directions, hasMore, rows };
     },
+    async restore(id, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        const global = expectedTable === void 0 ? globalFallback() : void 0;
+        if (global?.restore) {
+          await global.restore(id);
+          return;
+        }
+        throw new Error(`document not found: ${id}`);
+      }
+      const field = schema.tables[located.tableName]?.softDeleteMode?.field;
+      if (!field) {
+        throw new Error(`ctx.db.restore: table "${located.tableName}" is not a .softDelete() table`);
+      }
+      const wasDeleted = located.row[field] !== null && located.row[field] !== void 0;
+      await writer.patch(id, { [field]: null }, expectedTable);
+      if (wasDeleted) {
+        syncRanks(located.tableName, id, void 0, located.row);
+      }
+    },
     async replace(id, document, expectedTable) {
       const located = locateRowById(id, expectedTable);
       if (!located) {
@@ -1742,4 +1806,4 @@ const createShardCtxDb = (options) => {
   return options.enforceRls === true ? guardWriter(writer, schema, (id, expectedTable) => locateRowById(id, expectedTable)?.tableName) : writer;
 };
 
-export { NotUniqueError, appendCdcChange, assertValidClientId, createShardCtxDb, normalizeIdStructurally };
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally };

package/dist/packem_shared/{guardWriter-u3UlnCH5.mjs → RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs}

@@ -47,9 +47,9 @@ const guardWriter = (raw, schema, tableOfId) => {
       guardTable(tableName);
       return base.count(tableName, whereOrArgs);
     },
-    delete: async (id, expectedTable) => {
+    delete: async (id, expectedTable, options) => {
       await guardById(id, expectedTable);
-      return base.delete(id, expectedTable);
+      return base.delete(id, expectedTable, options);
     },
     deleteMany: async (ids, options, expectedTable) => {
       for (const id of ids) {
@@ -114,6 +114,10 @@ const guardWriter = (raw, schema, tableOfId) => {
     replace: async (id, document, expectedTable) => {
       await guardById(id, expectedTable);
       return base.replace(id, document, expectedTable);
+    },
+    restore: async (id, expectedTable) => {
+      await guardById(id, expectedTable);
+      return base.restore?.(id, expectedTable);
     }
   };
   if (baseRankBefore) {

package/dist/packem_shared/{ROOT_DO_SIZE_WARN_BYTES-DQkmGiCS.mjs → ROOT_DO_SIZE_WARN_BYTES-3lZ2yigq.mjs}

@@ -1,19 +1,19 @@
 import { drizzle } from 'drizzle-orm/durable-sqlite';
 import { parseExportShardArgs, parseImportShardArgs } from './exportShardRows-DZEhUeyI.mjs';
-import { recordAuthEvent, readAuthMetrics } from './AUTH_METRICS_BUCKET_MS-CiHHYeJi.mjs';
+import { recordAuthEvent, readAuthMetrics } from './AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs';
 import { DATA_MIGRATION_STATE_TABLE, readMigrationStatus } from './DATA_MIGRATION_STATE_TABLE-PTtTiQ7U.mjs';
 import { SCAN_DEP, createDependencyTracker, tableFromDepKey } from './SCAN_DEP-DLJF8dsj.mjs';
-import { readFunctionMetricsTotals, readFunctionMetricIndexHits, recordFunctionMetric, mergeScanAttribution, readFunctionMetrics, readFunctionMetricBuckets } from './ensureFunctionMetricsTables-UDNVD7FS.mjs';
-import { ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, selectMatchingIds, ADMIN_FUNCTIONS, findStorageReferences, listTables, summarizeSubscriptions, readTablePage, facetColumn, MAX_PAGE_SIZE } from './ADMIN_FUNCTION_PREFIX-Dzdqq5J2.mjs';
+import { readFunctionMetricsTotals, readFunctionMetricIndexHits, recordFunctionMetric, mergeScanAttribution, readFunctionMetrics, readFunctionMetricBuckets } from './FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs';
+import { ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, selectMatchingIds, ADMIN_FUNCTIONS, findStorageReferences, listTables, summarizeSubscriptions, readTablePage, facetColumn, MAX_PAGE_SIZE } from './ADMIN_FUNCTIONS-Dzdqq5J2.mjs';
 import { LogBuffer } from './LogBuffer-B_Ezju_N.mjs';
-import { recordCapturedMail, clearCapturedMail, readCapturedMail, MAIL_TABLE } from './clearCapturedMail-CPpgl-dX.mjs';
+import { recordCapturedMail, clearCapturedMail, readCapturedMail, MAIL_TABLE } from './MAIL_RETENTION-CPpgl-dX.mjs';
 import { readBookmark, armRestore } from './armRestore-BJk53Ro8.mjs';
 import { ReactiveCache, reactiveCacheKey } from './ReactiveCache-ByVzgH3d.mjs';
 import { redact, standardRules } from '@visulima/redact';
 import { i as isDevEnvironment, c as buildSettings, b as buildSecurityAudit } from './security-audit-CucgBice.mjs';
-import { runReadonlySql } from './assertReadonly-dDcFE1YZ.mjs';
+import { runReadonlySql } from './MAX_SQL_ROWS-dDcFE1YZ.mjs';
 import { ConflictError } from './ConflictError-C0STs6bU.mjs';
-import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './applyCdcChanges-Ctdmxmrv.mjs';
+import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-Ctdmxmrv.mjs';
 import { r as readIdempotent, w as writeIdempotent, t as trimIdempotent } from './ctx-db-idempotency-DkC9rP91.mjs';
 
 const AUDIT_LOG_TABLE = "__lunora_audit__";
@@ -1648,20 +1648,14 @@ class ShardDO {
         status: 500
       });
     }
-    const sqlExec = sqlHandle.exec.bind(sqlHandle);
+    const transactionalStorage = this.state.storage;
     const run = async () => {
       this.transactionDepth = 1;
-      sqlExec("BEGIN");
       try {
-        const value = await handler();
-        sqlExec("COMMIT");
-        return value;
-      } catch (error) {
-        try {
-          sqlExec("ROLLBACK");
-        } catch {
+        if (typeof transactionalStorage?.transaction === "function") {
+          return await transactionalStorage.transaction(async () => handler());
         }
-        throw error;
+        return await handler();
       } finally {
         this.transactionDepth = 0;
       }

package/dist/packem_shared/{applyOnDelete-CMif2RKw.mjs → applyOnDelete-sA7o1CqD.mjs}

@@ -1,3 +1,6 @@
+import { applySelect } from './applySelect-BvZdFUBT.mjs';
+
+const projectChildren = (documents, nested) => nested.select ? applySelect(documents, nested.select, nested.with) : documents;
 const distinctValues = (rows, field) => {
   const seen = /* @__PURE__ */ new Set();
   for (const row of rows) {
@@ -44,7 +47,8 @@ const resolveWith = async (options) => {
       byReference.set(child[relation.references], child);
     }
     for (const parent of parents) {
-      parent[name] = byReference.get(parent[relation.field]) ?? null;
+      const child = byReference.get(parent[relation.field]);
+      parent[name] = child ? projectChildren([child], nested)[0] ?? null : null;
     }
   };
   const loadMany = async (name, relation, nested) => {
@@ -77,7 +81,7 @@ const resolveWith = async (options) => {
     const cap = typeof nested.limit === "number" ? Math.max(0, Math.floor(nested.limit)) : void 0;
     for (const parent of parents) {
       const group = groups.get(parent[relation.references]) ?? [];
-      parent[name] = cap === void 0 ? group : group.slice(0, cap);
+      parent[name] = projectChildren(cap === void 0 ? group : group.slice(0, cap), nested);
     }
   };
   const resolveCounts = async (countInput) => {

package/dist/packem_shared/{buildSeekWhere-lVsNXSLy.mjs → applySelect-BvZdFUBT.mjs}

@@ -80,5 +80,22 @@ const buildSeekBeforeWhere = (keys, cursorValues) => {
   }
   return { OR: branches };
 };
+const SELECT_SYSTEM_FIELDS = ["_id", "_creationTime"];
+const applySelect = (page, select, withInput) => {
+  if (!select) {
+    return page;
+  }
+  const keep = /* @__PURE__ */ new Set([...select, ...SELECT_SYSTEM_FIELDS, ...withInput ? Object.keys(withInput) : []]);
+  return page.map((document) => {
+    const projected = {};
+    for (const key of keep) {
+      if (key in document) {
+        projected[key] = document[key];
+      }
+    }
+    return projected;
+  });
+};
+const softDeleteScope = (softDeleteMode, includeDeleted) => softDeleteMode && includeDeleted !== true ? { [softDeleteMode.field]: { isNull: true } } : void 0;
 
-export { buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys };
+export { applySelect, buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope };

package/dist/packem_shared/{backfillAggregateIndexes-BF5eL7kW.mjs → backfillAggregateIndexes-BbVPvciS.mjs}

@@ -1,5 +1,5 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere } from './matchesStaticWhere-CFk6adSu.mjs';
+import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';

package/dist/packem_shared/{runShardMigrations-C3bn5r93.mjs → runShardMigrations-PabobOjF.mjs}

@@ -1,11 +1,11 @@
 import { sql } from 'drizzle-orm';
 import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
-import { migrateCdcLog, migrateCdcMeta } from './applyCdcChanges-Ctdmxmrv.mjs';
+import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-Ctdmxmrv.mjs';
 import { m as migrateIdempotency } from './ctx-db-idempotency-DkC9rP91.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 { s as sortColumnName, r as rankTableName } from './rank-CrkEIpF4.mjs';
-import { ftsTableName } from './ftsTableName-BLEMawrp.mjs';
+import { ftsTableName } from './buildFtsMatch-BLEMawrp.mjs';
 
 const migrateSecondaryIndexes = (sql$1, tableName, definition) => {
   for (const index of definition.indexes) {

package/dist/packem_shared/{serveRelationFanout-Clr1a05L.mjs → serveRelationFanout-CFBKWJ8Q.mjs}

@@ -1,4 +1,4 @@
-import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTION_PREFIX-Dzdqq5J2.mjs';
+import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-Dzdqq5J2.mjs';
 
 const serveRelationFanout = async (schema, database, functionPath, args) => {
   const table = typeof args["table"] === "string" ? args["table"] : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.5",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",