@lunora/sql-store 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export { createSqlCtxDb, decodeGlobalRow, readSqlCdcChanges, runSqlAggregateMigrations, runSqlCdcMigration, runSqlGlobalTableMigrations, runSqlRankMigrations, runSqlSearchMigrations, trimSqlCdcChanges } from './packem_shared/createSqlCtxDb-CQFYyQLP.mjs';
-export { decodeBigint, effectiveColumnKind, sqliteDecode, sqliteEncode, tryJsonParse } from './packem_shared/sqliteEncode-Dedu92k4.mjs';
+export { createSqlCtxDb, decodeGlobalRow, readSqlCdcChanges, runSqlAggregateMigrations, runSqlCdcMigration, runSqlGlobalTableMigrations, runSqlRankMigrations, runSqlSearchMigrations, trimSqlCdcChanges } from './packem_shared/createSqlCtxDb-BDqIfMnS.mjs';
+export { decodeBigint, effectiveColumnKind, sqliteDecode, sqliteEncode, tryJsonParse } from './packem_shared/decodeBigint-Dedu92k4.mjs';

package/dist/packem_shared/{createSqlCtxDb-CQFYyQLP.mjs → createSqlCtxDb-BDqIfMnS.mjs}

@@ -1,6 +1,6 @@
-import { aggregateTableName, rankTableName, ftsTableName, hasTrigger, runRowValidators, assertFlatPredicate, mergeWhere, sortColumnName, resolveRankPartition, encodePartitionKey, decodeCursor, RANK_TIEBREAK, CountRlsUnsupportedError, normalizeIdStructurally, assertValidClientId, aggregateSqlFunction, compileWhereSql, normalizeOrderKeys, buildSeekWhere, resolveRelationPredicates, resolveWith, encodeCursor, NotFoundError, applyOnDelete, ConflictError, normalizeCountArgument, selectIndexForCount, encodeAggregateKey, selectIndexForAggregate, readAggregateValue, renderSql, runTriggers, matchesRankStaticWhere, stringifySearchText, selectIndexForGroupBy, matchesStaticWhere, coerceAggregateNumber, foldAggregateTally, NotUniqueError, throwingScheduler, tokenizeSearch, buildFtsMatch, scoreDocument } from '@lunora/do';
+import { aggregateTableName, rankTableName, ftsTableName, hasTrigger, runRowValidators, assertFlatPredicate, mergeWhere, sortColumnName, resolveRankPartition, encodePartitionKey, decodeCursor, RANK_TIEBREAK, CountRlsUnsupportedError, normalizeIdStructurally, assertValidClientId, aggregateSqlFunction, softDeleteScope, compileWhereSql, normalizeOrderKeys, buildSeekWhere, resolveRelationPredicates, resolveWith, applySelect, encodeCursor, NotFoundError, applyOnDelete, ConflictError, normalizeCountArgument, selectIndexForCount, encodeAggregateKey, selectIndexForAggregate, readAggregateValue, renderSql, runTriggers, matchesRankStaticWhere, stringifySearchText, selectIndexForGroupBy, fanOutScalarCounts, matchesStaticWhere, coerceAggregateNumber, foldAggregateTally, NotUniqueError, throwingScheduler, tokenizeSearch, buildFtsMatch, scoreDocument } from '@lunora/do';
 import { sql } from 'drizzle-orm';
-import { sqliteDecode, effectiveColumnKind, sqliteEncode } from './sqliteEncode-Dedu92k4.mjs';
+import { sqliteDecode, sqliteEncode, effectiveColumnKind } from './decodeBigint-Dedu92k4.mjs';
 
 const physicalColumn = (field) => field === "_id" || field === "id" ? "id" : field;
 const columnRefSql = (field) => sql`${sql.identifier(physicalColumn(field))}`;
@@ -79,14 +79,23 @@ const tableColumns = (definition) => {
   }
   return columns;
 };
+const columnKindCache = /* @__PURE__ */ new WeakMap();
+const columnKinds = (definition) => {
+  let kinds = columnKindCache.get(definition);
+  if (kinds === void 0) {
+    kinds = Object.entries(definition.shape).map(([field, validator]) => [field, effectiveColumnKind(validator)]);
+    columnKindCache.set(definition, kinds);
+  }
+  return kinds;
+};
 const decodeGlobalRow = (definition, row) => {
   const decoded = {};
-  for (const [field, validator] of Object.entries(definition.shape)) {
+  for (const [field, kind] of columnKinds(definition)) {
     const raw = row[field];
     if (raw === void 0) {
       continue;
     }
-    decoded[field] = sqliteDecode(raw, effectiveColumnKind(validator));
+    decoded[field] = sqliteDecode(raw, kind);
   }
   decoded["_id"] = row["id"];
   decoded["_creationTime"] = row["_creationTime"];
@@ -212,6 +221,9 @@ const searchViaFts = async (exec, dialect, definition, tableName, search, limit)
   for (const filter of search.filters) {
     conditions.push(sql`m.${columnRefSql(filter.field)} = ${serializeColumnValue(filter.value)}`);
   }
+  if (definition.softDeleteMode) {
+    conditions.push(sql`m.${columnRefSql(definition.softDeleteMode.field)} IS NULL`);
+  }
   let query = sql`SELECT m.* FROM ${sql.identifier(ftName)} f JOIN ${sql.identifier(tableName)} m ON m.${sql.identifier("id")} = f.${sql.identifier("__id__")} WHERE ${sql.join(conditions, sql` AND `)} ORDER BY f.rank, m.${sql.identifier("_creationTime")} DESC`;
   if (typeof limit === "number") {
     query = sql`${query} LIMIT ${sql.raw(String(Math.max(0, Math.floor(limit))))}`;
@@ -225,6 +237,9 @@ const searchViaScan = async (exec, dialect, definition, tableName, search, limit
     return [];
   }
   const conditions = search.filters.map((filter) => sql`${columnRefSql(filter.field)} = ${serializeColumnValue(filter.value)}`);
+  if (definition.softDeleteMode) {
+    conditions.push(sql`${columnRefSql(definition.softDeleteMode.field)} IS NULL`);
+  }
   let query = sql`SELECT * FROM ${sql.identifier(tableName)}`;
   if (conditions.length > 0) {
     query = sql`${query} WHERE ${sql.join(conditions, sql` AND `)}`;
@@ -562,7 +577,12 @@ const createSqlCtxDb = (options) => {
     fieldRef: columnRefSql,
     serialize: serializeColumnValue,
     // MySQL has no `||` string concat; the rest use the portable form compileWhereSql defaults to.
-    ...dialect.name === "mysql" ? { likeContains: (reference, term) => sql`${reference} LIKE CONCAT('%', ${term}, '%')` } : {}
+    // The term is wildcard-escaped by compileContains, so pair it with a backslash `ESCAPE` for literal
+    // matching. MySQL treats backslash as a string-literal escape, so the SQL text must contain a DOUBLED
+    // backslash (`ESCAPE '\\'`) to denote one literal backslash; drizzle's `sql` tag uses the COOKED
+    // template string, so `'\\\\'` here renders `'\\'` in the SQL (a single `'\'` would escape the closing
+    // quote and raise a syntax error). SQLite/Postgres take backslash literally and use the portable default.
+    ...dialect.name === "mysql" ? { likeContains: (reference, term) => sql`${reference} LIKE CONCAT('%', ${term}, '%') ESCAPE '\\\\'` } : {}
   };
   const nullSafeEquals = (reference, value) => nullSafeEqualsSql(dialect.name, reference, value);
   const upsertSql = (config) => {
@@ -1122,10 +1142,11 @@ const createSqlCtxDb = (options) => {
       if (!aggOptions.field) {
         throw new Error(`aggregate(${tableName}, { op: "${aggOptions.op}" }): "field" is required for non-count reducers`);
       }
-      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) {
           const counterReady = await ensureBackfilled(tableName, planned.index);
@@ -1159,10 +1180,11 @@ const createSqlCtxDb = (options) => {
       if (countOptions.restrictsCounts) {
         throw new CountRlsUnsupportedError(tableName);
       }
-      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) {
           const counterReady = await ensureBackfilled(tableName, planned.index);
@@ -1183,7 +1205,7 @@ const createSqlCtxDb = (options) => {
       const rows = await queryAll(exec, dialect, whereCondition ? sql`${query} WHERE ${whereCondition}` : query);
       return Number(rows[0]?.["count"] ?? 0);
     },
-    async delete(id, expectedTable) {
+    async delete(id, expectedTable, deleteOptions) {
       const tableName = await resolveTableName(id, expectedTable);
       if (!tableName) {
         return;
@@ -1194,6 +1216,11 @@ const createSqlCtxDb = (options) => {
       }
       const snapshot = await rawRow(tableName, id);
       const existing = decodeRow(definition, snapshot);
+      const hard = deleteOptions?.hard === true;
+      const softField = !hard && definition.softDeleteMode ? definition.softDeleteMode.field : void 0;
+      if (softField && (!existing || existing[softField] !== null && existing[softField] !== void 0)) {
+        return;
+      }
       if (hasMatchingTrigger(tableName, "before", "delete")) {
         await fireTriggers("before", "delete", { id, op: "delete", previous: existing ?? void 0, table: tableName });
       }
@@ -1206,10 +1233,10 @@ const createSqlCtxDb = (options) => {
               `cross-backend cascade from global '${tableName}' into shardBy '${holderTable}' is not supported — would require Query Coordinator fan-out across shards`
             );
           }
-          const holders = await writer.findMany(holderTable, { where: { [field]: value } });
+          const holders = await writer.findMany(holderTable, { includeDeleted: hard, where: { [field]: value } });
           return holders.page;
         },
-        onCascade: (_holderTable, holderId) => writer.delete(holderId),
+        onCascade: (_holderTable, holderId) => writer.delete(holderId, void 0, deleteOptions),
         onRestrict: (message) => {
           throw new ConflictError(message, "restrict");
         },
@@ -1220,6 +1247,23 @@ const createSqlCtxDb = (options) => {
       });
       await ensureBackfilledForTable(tableName);
       await ensureRankBackfilledForTable(tableName);
+      if (softField && existing) {
+        const merged = { ...existing, [softField]: clock() };
+        const assignments = sql.join(
+          // eslint-disable-next-line unicorn/no-null -- SQL bind value: an absent column binds `null`, matching the patch path.
+          Object.keys(definition.shape).map((field) => sql`${sql.identifier(field)} = ${serializeColumnValue(merged[field] ?? null)}`),
+          sql`, `
+        );
+        await runGuardedWrite(tableName, "UPDATE", assignments, snapshot);
+        await syncAggregates(tableName, existing, merged);
+        await syncRanks(tableName, id, existing, void 0);
+        await syncSearch(tableName, id, merged);
+        await recordCdc(tableName, id, "update", merged);
+        if (hasMatchingTrigger(tableName, "after", "delete")) {
+          await fireTriggers("after", "delete", { id, op: "delete", previous: existing, table: tableName });
+        }
+        return;
+      }
       await runGuardedWrite(tableName, "DELETE", void 0, snapshot);
       tableNameCache.delete(id);
       await syncAggregates(tableName, existing ?? void 0, void 0);
@@ -1250,13 +1294,37 @@ const createSqlCtxDb = (options) => {
       const orderKeys = normalizeOrderKeys(args.orderBy);
       const seek = args.cursor ? buildSeekWhere(orderKeys, decodeCursor(args.cursor)) : void 0;
       const relationFetcher = relationPredicateFetcher;
-      const relationCounter = (childTable, where) => {
-        if (!isShardLocalTarget(childTable)) {
-          return writer.count(childTable, where);
+      const relationGroupedCounter = async (childTable, whereField, values, policyWhere) => {
+        if (isShardLocalTarget(childTable)) {
+          if (!crossShardCounter) {
+            return crossBackendUnsupported(childTable);
+          }
+          return fanOutScalarCounts(crossShardCounter, childTable, whereField, values, policyWhere);
         }
-        return crossShardCounter ? crossShardCounter(childTable, where) : crossBackendUnsupported(childTable);
+        const childDefinition = schema.tables[childTable];
+        if (!childDefinition) {
+          throw new Error(`unknown table: ${childTable}`);
+        }
+        const softScope = softDeleteScope(childDefinition.softDeleteMode, void 0);
+        const inFilter = { [whereField]: { in: values } };
+        const combined = mergeWhere(mergeWhere(inFilter, policyWhere), softScope);
+        const resolvedCombined = await resolveAggregateRelations(combined, childTable, void 0);
+        const whereCondition2 = compileWhereSql(resolvedCombined, whereSqlStrategy);
+        const fieldRef = columnRefSql(whereField);
+        let groupQuery = sql`SELECT ${fieldRef} AS __fk__, COUNT(*) AS count FROM ${sql.identifier(childTable)}`;
+        if (whereCondition2) {
+          groupQuery = sql`${groupQuery} WHERE ${whereCondition2}`;
+        }
+        groupQuery = sql`${groupQuery} GROUP BY ${fieldRef}`;
+        const groupRows = await queryAll(exec, dialect, groupQuery);
+        const result = /* @__PURE__ */ new Map();
+        for (const row of groupRows) {
+          result.set(row["__fk__"], Number(row["count"] ?? 0));
+        }
+        return result;
       };
       let predicate = mergeWhere(args.baseWhere, args.where);
+      predicate = mergeWhere(predicate, softDeleteScope(definition.softDeleteMode, args.includeDeleted));
       predicate = await resolveRelationPredicates(predicate, {
         fetcher: relationFetcher,
         maxRelationKeys,
@@ -1282,21 +1350,30 @@ const createSqlCtxDb = (options) => {
       const documents = decodeRows(definition, rows);
       if (limit === void 0) {
         if (args.with) {
-          await resolveWith({ counter: relationCounter, fetcher: relationFetcher, parents: documents, schema, tableName, with: args.with });
+          await resolveWith({
+            fetcher: relationFetcher,
+            groupedCounter: relationGroupedCounter,
+            parents: documents,
+            schema,
+            tableName,
+            with: args.with
+          });
         }
-        return { continueCursor: null, isDone: true, page: documents };
+        return { continueCursor: null, isDone: true, page: applySelect(documents, args.select, args.with) };
       }
       const hasMore = documents.length > limit;
       const page = hasMore ? documents.slice(0, limit) : documents;
       const last = page.at(-1);
       if (args.with) {
-        await resolveWith({ counter: relationCounter, fetcher: relationFetcher, parents: page, schema, tableName, with: args.with });
+        await resolveWith({ fetcher: relationFetcher, groupedCounter: relationGroupedCounter, parents: page, schema, tableName, with: args.with });
       }
       return {
+        // The cursor is encoded from `last` (the full, unprojected row), so
+        // `applySelect` only trims the returned payload — paging is intact.
         // eslint-disable-next-line unicorn/no-null -- public return shape: `continueCursor` is `string | null`; `null` marks the final page.
         continueCursor: hasMore && last ? encodeCursor(last, orderKeys) : null,
         isDone: !hasMore,
-        page
+        page: applySelect(page, args.select, args.with)
       };
     },
     async get(id, expectedTable) {
@@ -1322,10 +1399,11 @@ const createSqlCtxDb = (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 indexed = await tryIndexedGroupBy(tableName, definition.aggregateIndexes, agg, groupOptions);
         if (indexed !== void 0) {
           return indexed;
@@ -1452,6 +1530,26 @@ const createSqlCtxDb = (options) => {
         await fireTriggers("after", "update", { doc: merged, id, op: "update", previous: existing, table: tableName });
       }
     },
+    async restore(id, expectedTable) {
+      const tableName = await resolveTableName(id, expectedTable);
+      if (!tableName) {
+        throw new Error(`document not found: ${id}`);
+      }
+      const definition = schema.tables[tableName];
+      const field = definition?.softDeleteMode?.field;
+      if (!definition || !field) {
+        throw new Error(`ctx.db.restore: table "${tableName}" is not a .softDelete() table`);
+      }
+      const snapshot = await rawRow(tableName, id);
+      const wasDeleted = snapshot?.[field] !== null && snapshot?.[field] !== void 0;
+      await writer.patch(id, { [field]: null }, expectedTable);
+      if (wasDeleted) {
+        const row = decodeRow(definition, snapshot);
+        if (row !== null) {
+          await syncRanks(tableName, id, void 0, row);
+        }
+      }
+    },
     query(tableName) {
       const definition = schema.tables[tableName];
       if (!definition) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/sql-store",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.20",
   "description": "Internal dialect-parameterized SQL store core for Lunora .global() backends (D1, PlanetScale)",
   "keywords": [
     "cloudflare",
@@ -25,7 +25,7 @@
     "directory": "packages/sql-store"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"
@@ -50,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/do": "1.0.0-alpha.2",
+    "@lunora/do": "1.0.0-alpha.20",
     "drizzle-orm": "^0.45.2"
   },
   "engines": {