akanjs 3.1.0-rc.24 → 3.1.0-rc.26

package/document/database.ts

@@ -96,6 +96,8 @@ type QueryMethodOfKey<
   [K in `remove${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
 } & {
   [K in `removeOne${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+  [K in `purge${CapitalizedK}`]: (...args: _Args) => Promise<number>;
 } & {
   [K in `update${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
 } & {
@@ -154,6 +156,7 @@ export type DatabaseInstanceWithQuerySort<
   __remove: (id: string) => Promise<Doc>;
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
   __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __purgeMany: (query: _QueryOfDoc) => Promise<number>;
   __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;

package/document/into.ts

@@ -83,6 +83,8 @@ export type Mdl<
   ): Promise<UpdateResult>;
   removeOne(query: _RawQuery): Promise<UpdateResult>;
   removeMany(query: _RawQuery): Promise<UpdateResult>;
+  /** Deletes every row the query matches, removed ones too, and answers how many: no hook, cascade or undo. */
+  purgeMany(query: _RawQuery): Promise<number>;
   updateById(id: string, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
   removeById(id: string): Promise<UpdateResult>;
   /**

package/fetch/fetchType/endpointFetch.type.ts

@@ -14,15 +14,17 @@ import type {
   SliceCls,
 } from "akanjs/signal";
 
-type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = ClientReturns extends (infer R)[]
-  ? ExtendedEndpointReturn<R, Full, Light, Insight>[]
-  : Full extends ClientReturns
-    ? Full
-    : Light extends ClientReturns
-      ? Light
-      : Insight extends ClientReturns
-        ? Insight
-        : ClientReturns;
+type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = unknown extends ClientReturns
+  ? ClientReturns
+  : ClientReturns extends (infer R)[]
+    ? ExtendedEndpointReturn<R, Full, Light, Insight>[]
+    : Full extends ClientReturns
+      ? Full
+      : Light extends ClientReturns
+        ? Light
+        : Insight extends ClientReturns
+          ? Insight
+          : ClientReturns;
 
 type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] extends [never]
   ? EndpInfoClientReturns<E>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.1.0-rc.24",
+  "version": "3.1.0-rc.26",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/resolver/database.resolver.ts

@@ -291,6 +291,7 @@ export class DatabaseResolver {
             timedQuery(() => store.updateManyByQuery(query, update, ...scopeArgs(options))),
           removeOne: (query: QueryOf<any>) => timedQuery(() => store.removeOneByQuery(query)),
           removeMany: (query: QueryOf<any>) => timedQuery(() => store.removeManyByQuery(query)),
+          purgeMany: (query: QueryOf<any>) => timedQuery(() => store.purgeManyByQuery(query)),
           updateById: (id: string, update: DocumentUpdateInput, options?: DocumentUpdateOptions) =>
             timedQuery(() => store.updateOneByQuery({ id }, update, options)),
           removeById: (id: string) => timedQuery(() => store.removeOneByQuery({ id })),
@@ -397,6 +398,9 @@ export class DatabaseResolver {
       async __removeOne(query: QueryOf<any>) {
         return await timedQuery(() => this.__store.removeOneByQuery(query));
       }
+      async __purgeMany(query: QueryOf<any>) {
+        return await timedQuery(() => this.__store.purgeManyByQuery(query));
+      }
       async __updateMany(query: QueryOf<any>, update: DocumentUpdateInput) {
         return await timedQuery(() => this.__store.updateManyByQuery(query, update));
       }

package/server/resolver/service.resolver.ts

@@ -35,6 +35,9 @@ export class ServiceResolver {
       async __removeOne(this: DatabaseService, query: QueryOf<any>) {
         return await this.__databaseModel.__removeOne(query);
       },
+      async __purgeMany(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__purgeMany(query);
+      },
       async __updateMany(this: DatabaseService, query: QueryOf<any>, update: DocumentUpdateInput) {
         return await this.__databaseModel.__updateMany(query, update);
       },

package/service/predefinedAdaptor/database.adaptor.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import type { PromiseOrObject } from "akanjs/base";
 import type { ConstantModel } from "akanjs/constant";
 import type { DatabaseModel, DocumentSchema, SchemaOf } from "akanjs/document";
-import type { Sql } from "postgres";
+import type { ReservedSql, Sql } from "postgres";
 import { adapt } from "../adapt";
 import { ScheduleAdaptorRole } from "./role.adaptor";
 import {
@@ -185,6 +185,16 @@ export class SqliteDatabase
       .run(key, value, Date.now());
   }
 
+  listMeta(prefix: string) {
+    return this.#db
+      .query(`SELECT "key", "value" FROM "_akan_meta" WHERE substr("key", 1, ?) = ?`)
+      .all(prefix.length, prefix) as { key: string; value: string }[];
+  }
+
+  async deleteMeta(key: string) {
+    await this.#client.prepare(`DELETE FROM "_akan_meta" WHERE "key" = ?`).run(key);
+  }
+
   async transaction<T>(fn: () => PromiseOrObject<T>): Promise<T> {
     const active = this.#transaction.getStore();
     if (active) return await fn();
@@ -438,6 +448,16 @@ export class PostgresDatabase
       .run(key, value, Date.now());
   }
 
+  async listMeta(prefix: string) {
+    return await this.getConnection()
+      .prepare(`SELECT "key", "value" FROM "_akan_meta" WHERE substr("key", 1, $1) = $2`)
+      .all<{ key: string; value: string }>(prefix.length, prefix);
+  }
+
+  async deleteMeta(key: string) {
+    await this.getConnection().prepare(`DELETE FROM "_akan_meta" WHERE "key" = $1`).run(key);
+  }
+
   async transaction<T>(fn: () => PromiseOrObject<T>): Promise<T> {
     const active = this.#transaction.getStore();
     if (active) return await fn();
@@ -491,35 +511,47 @@ export class PostgresDatabase
   }
 
   async buildIndexConcurrently({ name, next, create, replace }: ConcurrentIndexBuild) {
+    await this.#underIndexLock(name, async (reserved) => {
+      const valid = async (index: string) =>
+        (
+          await reserved.unsafe(`SELECT indisvalid AS "valid" FROM pg_index WHERE indexrelid = to_regclass($1)`, [
+            quoteIdent(index),
+          ])
+        ).at(0)?.valid as boolean | undefined;
+      if (!replace) {
+        const state = await valid(name);
+        if (state) return;
+        if (state === false) await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(name)}`);
+        await reserved.unsafe(create(name));
+        return;
+      }
+      
+      await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
+      try {
+        await reserved.unsafe(create(next));
+      } catch (error) {
+        await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
+        throw error;
+      }
+      await reserved.unsafe(
+        `DROP INDEX IF EXISTS ${quoteIdent(name)}; ALTER INDEX ${quoteIdent(next)} RENAME TO ${quoteIdent(name)}`,
+      );
+    });
+  }
+
+  async dropIndexConcurrently(name: string) {
+    await this.#underIndexLock(name, async (reserved) => {
+      await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(name)}`);
+    });
+  }
+
+  async #underIndexLock(name: string, fn: (reserved: ReservedSql) => Promise<void>) {
     const reserved = await this.#sql.reserve();
     const key = `akan:index:${name}`;
-    const valid = async (index: string) =>
-      (
-        await reserved.unsafe(`SELECT indisvalid AS "valid" FROM pg_index WHERE indexrelid = to_regclass($1)`, [
-          quoteIdent(index),
-        ])
-      ).at(0)?.valid as boolean | undefined;
     try {
       await reserved.unsafe(`SELECT pg_advisory_lock(hashtext(current_schema() || $1))`, [key]);
       try {
-        if (!replace) {
-          const state = await valid(name);
-          if (state) return;
-          if (state === false) await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(name)}`);
-          await reserved.unsafe(create(name));
-          return;
-        }
-        
-        await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
-        try {
-          await reserved.unsafe(create(next));
-        } catch (error) {
-          await reserved.unsafe(`DROP INDEX CONCURRENTLY IF EXISTS ${quoteIdent(next)}`);
-          throw error;
-        }
-        await reserved.unsafe(
-          `DROP INDEX IF EXISTS ${quoteIdent(name)}; ALTER INDEX ${quoteIdent(next)} RENAME TO ${quoteIdent(name)}`,
-        );
+        await fn(reserved);
       } finally {
         await reserved.unsafe(`SELECT pg_advisory_unlock(hashtext(current_schema() || $1))`, [key]);
       }

package/service/predefinedAdaptor/sql/SqlDocumentStore.ts

@@ -5,6 +5,7 @@ import { Err } from "akanjs/dictionary";
 import {
   createDocumentId,
   type DatabaseModel,
+  type DocumentIndexDescriptor,
   type DocumentQuery,
   type DocumentSchema,
   type DocumentScopeOptions,
@@ -66,12 +67,17 @@ interface DeclaredIndex {
   next: string;
   metaKey: string;
   hash: string;
-  fields: Record<string, unknown>;
-  /** A key ordered neither 1 nor -1, as MongoDB's `"text"`: no SQL index here stands for it. */
-  unbuilt: boolean;
+  /** Every descriptor that declares this very index, so a copy an earlier release built under any of them serves it. */
+  hashes: Set<string>;
   create: (name: string, concurrently: boolean) => string;
 }
 
+interface StaleIndex {
+  name: string;
+  metaKey: string;
+  exists: boolean;
+}
+
 type StoredRow = Omit<SqliteDocumentRow, "id">;
 
 const freshDefault = (value: unknown) => (Array.isArray(value) ? [...(value as unknown[])] : value);
@@ -91,6 +97,7 @@ export class SqlDocumentStore {
   static readonly #storedRow = Symbol("akan.storedRow");
   /** Set on a document read as removed, which only a `withRemoved` read hands out. */
   static readonly #readRemoved = Symbol("akan.readRemoved");
+  static readonly #purgeBatchRows = 1000;
 
   constructor(
     private readonly owner: DocumentDatabaseOwner,
@@ -114,8 +121,8 @@ export class SqlDocumentStore {
 
   async #ensure() {
     this.assertValidRefName(this.table);
-    const declared = await this.#declaredIndexes();
-    const indexes = declared.filter((index) => !index.unbuilt);
+    const indexes = await this.#declaredIndexes();
+    for (const index of this.schema.indexes) if (!SqlDocumentStore.#builds(index)) this.#warnUnbuilt(index);
     const createSchema = async () => {
       const db = this.owner.getConnection();
       const existed = !!this.owner.buildIndexConcurrently && !!(await this.owner.hasTable?.(this.table));
@@ -134,9 +141,10 @@ export class SqlDocumentStore {
         `table:${this.table}`,
         await descriptorHash({ table: this.table, columns: ["id", "createdAt", "updatedAt", "removedAt", "_doc"] }),
       );
-      for (const index of declared) if (index.unbuilt) await this.#skipUnbuiltIndex(index, indexes);
+      const { adopted, stale } = await this.#reconcileIndexes(indexes);
       const concurrent: (DeclaredIndex & { replace: boolean })[] = [];
       for (const index of indexes) {
+        if (adopted.has(index.name)) continue;
         const stored = await this.owner.getMeta(index.metaKey);
         const replace = !!stored && stored !== index.hash;
         if (replace)
@@ -155,51 +163,141 @@ export class SqlDocumentStore {
         else await db.execute(index.create(index.name, false));
         await this.owner.setMeta(index.metaKey, index.hash);
       }
-      return concurrent;
+      const drops: StaleIndex[] = [];
+      for (const index of stale) {
+        if (!index.exists) await this.owner.deleteMeta(index.metaKey);
+        else if (this.owner.dropIndexConcurrently) drops.push(index);
+        else await this.#dropStaleIndex(index);
+      }
+      return { concurrent, drops };
     };
-    const concurrent = this.owner.lockSchema ? await this.owner.lockSchema(createSchema) : await createSchema();
+    const { concurrent, drops } = this.owner.lockSchema
+      ? await this.owner.lockSchema(createSchema)
+      : await createSchema();
     for (const { name, next, create, replace, metaKey, hash } of concurrent) {
       await this.owner.buildIndexConcurrently?.({ name, next, create: (target) => create(target, true), replace });
       await this.owner.setMeta(metaKey, hash);
     }
+    for (const index of drops) await this.#dropStaleIndex(index);
     await this.owner.getSearchIndex()?.ensureRef(this.constant, this.database);
   }
 
+  static #builds(index: DocumentIndexDescriptor) {
+    return Object.values(index.fields).every((order) => order === 1 || order === -1);
+  }
+
   async #declaredIndexes(): Promise<DeclaredIndex[]> {
-    return await Promise.all(
-      this.schema.indexes.map(async (index, idx) => {
-        const declared = index.name ?? `${this.table}_${Object.keys(index.fields).map(toSafeRefName).join("_")}_${idx}`;
-        this.assertValidRefName(declared);
-        const name = this.dialect.indexName(declared);
-        const unbuilt = Object.values(index.fields).some((order) => order !== 1 && order !== -1);
-        const columns = unbuilt
-          ? []
-          : Object.keys(index.fields).map((path) => ({
-              path,
-              expr: this.compiler.fieldExpr(path),
-              isArray: this.compiler.isArrayPath(path),
-            }));
-        const predicate = unbuilt || !index.where ? undefined : this.#indexPredicate(index.where, name);
+    const candidates = await Promise.all(
+      this.schema.indexes.filter(SqlDocumentStore.#builds).map(async (descriptor) => {
+        const paths = Object.keys(descriptor.fields);
+        const base =
+          descriptor.name ??
+          [this.table, ...paths.map(toSafeRefName), ...(descriptor.unique ? ["unique"] : [])].join("_");
+        const columns = paths.map((path) => ({
+          path,
+          expr: this.compiler.fieldExpr(path),
+          isArray: this.compiler.isArrayPath(path),
+        }));
+        const predicate = descriptor.where ? this.#indexPredicate(descriptor.where, base) : undefined;
+        const create = (target: string, concurrently: boolean) =>
+          this.dialect.createIndex({
+            name: target,
+            table: this.table,
+            unique: !!descriptor.unique,
+            columns,
+            concurrently,
+            where: predicate,
+          });
+        const definition = create("", false);
         return {
-          name,
-          next: this.dialect.indexName(`${declared}_next`),
-          metaKey: `index:${this.table}:${name}`,
+          named: !!descriptor.name,
+          base,
+          definition,
           
-          hash: await descriptorHash(predicate ? { ...index, predicate } : index),
-          fields: index.fields,
-          unbuilt,
-          create: (target: string, concurrently: boolean) =>
-            this.dialect.createIndex({
-              name: target,
-              table: this.table,
-              unique: !!index.unique,
-              columns,
-              concurrently,
-              where: predicate,
-            }),
+          hash: await descriptorHash(predicate ? { ...descriptor, predicate } : descriptor),
+          suffix: (await descriptorHash(definition)).slice(0, 8),
+          create,
         };
       }),
     );
+    const definitionsOf = new Map<string, Set<string>>();
+    for (const { base, definition } of candidates)
+      definitionsOf.set(base, (definitionsOf.get(base) ?? new Set()).add(definition));
+    const namedDefinitions = new Set(candidates.filter(({ named }) => named).map(({ definition }) => definition));
+    const indexes = new Map<string, DeclaredIndex>();
+    for (const { named, base, definition, hash, suffix, create } of candidates) {
+      if (!named && namedDefinitions.has(definition)) continue;
+      
+      const shared = (definitionsOf.get(base)?.size ?? 0) > 1;
+      if (
+        named &&
+        shared &&
+        candidates.some((other) => other.named && other.base === base && other.definition !== definition)
+      )
+        throw new Error(`Two different indexes on ${this.table} are both named ${base}`);
+      const declared = named || !shared ? base : `${base}_${suffix}`;
+      this.assertValidRefName(declared);
+      const name = this.dialect.indexName(declared);
+      const existing = indexes.get(name);
+      if (existing) {
+        existing.hashes.add(hash);
+        continue;
+      }
+      indexes.set(name, {
+        name,
+        next: this.dialect.indexName(`${declared}_next`),
+        metaKey: `index:${this.table}:${name}`,
+        hash,
+        hashes: new Set([hash]),
+        create,
+      });
+    }
+    return [...indexes.values()];
+  }
+
+  async #reconcileIndexes(indexes: DeclaredIndex[]) {
+    const prefix = `index:${this.table}:`;
+    const { sql, params } = this.dialect.indexesOf(this.table);
+    const rows = await this.owner
+      .getConnection()
+      .prepare(sql)
+      .all<{ name: string; valid: unknown }>(...params);
+    const physical = new Map(rows.map(({ name, valid }) => [name, !!valid]));
+    const declared = new Set(indexes.map(({ name }) => name));
+    const recorded = (await this.owner.listMeta(prefix)).map(({ key, value }) => ({
+      name: key.slice(prefix.length),
+      metaKey: key,
+      hash: value,
+    }));
+    const recordedNames = new Set(recorded.map(({ name }) => name));
+    const undeclared = recorded.filter(({ name }) => !declared.has(name)).sort((a, b) => a.name.localeCompare(b.name));
+    
+    const kept = new Set<string>();
+    const adopted = new Set<string>();
+    for (const index of indexes) {
+      if (recordedNames.has(index.name) || physical.has(index.name)) continue;
+      const copy = undeclared.find(({ name, hash }) => !kept.has(name) && index.hashes.has(hash) && physical.get(name));
+      if (!copy) continue;
+      kept.add(copy.name);
+      adopted.add(index.name);
+    }
+    const stale: StaleIndex[] = undeclared
+      .filter(({ name }) => !kept.has(name))
+      .map(({ name, metaKey }) => ({ name, metaKey, exists: physical.has(name) }));
+    return { adopted, stale };
+  }
+
+  async #dropStaleIndex({ name, metaKey }: StaleIndex) {
+    try {
+      if (this.owner.dropIndexConcurrently) await this.owner.dropIndexConcurrently(name);
+      else await this.owner.getConnection().execute(`DROP INDEX IF EXISTS ${quoteIdent(name)}`);
+      await this.owner.deleteMeta(metaKey);
+      SqlDocumentStore.#logger.info(`Dropped index ${name} on ${this.table}, which no declaration builds any more`);
+    } catch (error) {
+      SqlDocumentStore.#logger.warn(
+        `Index ${name} on ${this.table} is no longer declared, and dropping it failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 
   #indexPredicate(where: DocumentQuery, name: string) {
@@ -209,20 +307,13 @@ export class SqlDocumentStore {
     return sql === "1 = 1" ? undefined : inlineParams(sql, params);
   }
 
-  async #skipUnbuiltIndex(index: DeclaredIndex, built: DeclaredIndex[]) {
-    const dropped =
-      (await this.owner.getMeta(index.metaKey)) === index.hash && !built.some(({ name }) => name === index.name);
-    if (dropped) {
-      await this.owner.getConnection().execute(`DROP INDEX IF EXISTS ${quoteIdent(index.name)}`);
-      
-      await this.owner.setMeta(index.metaKey, "");
-    }
+  #warnUnbuilt(index: DocumentIndexDescriptor) {
     const paths = Object.keys(index.fields);
     SqlDocumentStore.#logger.warn(
       `Index ${JSON.stringify(index.fields)} on ${this.table} is not built: only 1 and -1 order a key, and "text" is ` +
         `MongoDB's text index, which as a B-tree would copy each whole value and fail long writes on Postgres. Search ` +
         `${paths.join(", ")} through the full-text role, field(String, { text: "desc" }), or declare ` +
-        `{ ${paths[0]}: 1 } to look it up by equality.${dropped ? ` Dropped ${index.name}, which an earlier boot built from it.` : ""}`,
+        `{ ${paths[0]}: 1 } to look it up by equality.`,
     );
   }
 
@@ -397,6 +488,43 @@ export class SqlDocumentStore {
     return await this.#updateOne(query, { removedAt: dayjs() }, {}, "removeOneByQuery");
   }
 
+  async purgeManyByQuery(query: DocumentQuery) {
+    
+    if (SqlDocumentStore.#matchesEveryRow(query))
+      throw new Error(
+        `purgeManyByQuery on "${this.table}" matches every row; a purge cannot be undone, so name a condition`,
+      );
+    const { where, params, joins } = this.compiler.compile(query);
+    if (joins.length)
+      throw new Error(
+        `q.search() cannot be used in purgeManyByQuery on "${this.table}"; query-level writes take no join.`,
+      );
+    const table = quoteIdent(this.table);
+    const batch = SqlDocumentStore.#purgeBatchRows;
+    
+    const statement = this.owner
+      .getConnection()
+      .prepare(
+        `DELETE FROM ${table} WHERE ${quoteIdent("id")} IN (SELECT ${quoteIdent("id")} FROM ${table} WHERE ${where} LIMIT ${batch}) AND (${where})`,
+      );
+    let purged = 0;
+    for (;;) {
+      const changes = this.dialect.affectedRows(await statement.run(...params, ...params));
+      purged += changes;
+      if (changes < batch) return purged;
+      
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+
+  static #matchesEveryRow(query: DocumentQuery): boolean {
+    if (!isDocumentQueryNode(query)) return Object.keys(query).length === 0;
+    if (query.kind === "all") return query.queries.every((sub) => SqlDocumentStore.#matchesEveryRow(sub));
+    if (query.kind === "any")
+      return !query.queries.length || query.queries.some((sub) => SqlDocumentStore.#matchesEveryRow(sub));
+    return false;
+  }
+
   private compiledUpdate(update: DocumentUpdate) {
     for (const raw of Object.values(update))
       assertStorableJson(jsonStr(isDocumentUpdateNode(raw) ? raw.value : raw), this.table);

package/service/predefinedAdaptor/sql/dialect/postgres.ts

@@ -171,6 +171,13 @@ export class PostgresDialect implements SqlDialect {
     
     return `${create} (${columns.map(({ expr }) => `${expr} NULLS FIRST`).join(", ")})${predicate}`;
   }
+  
+  indexesOf(table: string): SqlFrag {
+    return {
+      sql: `SELECT c.relname AS "name", i.indisvalid AS "valid" FROM pg_index i JOIN pg_class c ON c.oid = i.indexrelid WHERE i.indrelid = to_regclass(?) AND NOT i.indisprimary`,
+      params: [quoteIdent(table)],
+    };
+  }
   applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag {
     const p = this.#path(path);
     

package/service/predefinedAdaptor/sql/dialect/sqlite.ts

@@ -93,6 +93,13 @@ export class SqliteDialect implements SqlDialect {
   createIndex({ name, table, unique, columns, where }: CreateIndexProps) {
     return `CREATE ${unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${quoteIdent(name)} ON ${quoteIdent(table)} (${columns.map(({ expr }) => expr).join(", ")})${where ? ` WHERE ${where}` : ""}`;
   }
+  
+  indexesOf(table: string): SqlFrag {
+    return {
+      sql: `SELECT "name", 1 AS "valid" FROM "sqlite_master" WHERE "type" = 'index' AND "tbl_name" = ? AND "sql" IS NOT NULL`,
+      params: [table],
+    };
+  }
   applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag {
     const p = this.#path(path);
     

package/service/predefinedAdaptor/sql/types.ts

@@ -74,6 +74,7 @@ export interface DocumentStore {
   removeOneByQuery(
     query: DocumentQuery,
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number; upsertedId: string | null }>;
+  purgeManyByQuery(query: DocumentQuery): Promise<number>;
   bulkWrite(
     operations: { updateOne: { filter: DocumentQuery; update: DocumentUpdateInput; upsert?: boolean } }[],
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number; upsertedId: string | null }>;
@@ -193,6 +194,8 @@ export interface DocumentDatabaseOwner {
   getSearchIndex(): SearchIndex | null;
   getMeta(key: string): Promise<string | undefined> | string | undefined;
   setMeta(key: string, value: string): Promise<void>;
+  listMeta(prefix: string): Promise<{ key: string; value: string }[]> | { key: string; value: string }[];
+  deleteMeta(key: string): Promise<void>;
   afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
   transaction?<T>(fn: () => PromiseOrObject<T>): Promise<T>;
   /** Runs `fn` as the only schema change: Postgres races two `CREATE … IF NOT EXISTS` into a duplicate-key error. */
@@ -203,6 +206,8 @@ export interface DocumentDatabaseOwner {
   grantInsight?(table: string): Promise<void>;
   /** Builds an index on a table that already holds rows without blocking its writes; never inside a transaction. */
   buildIndexConcurrently?(build: ConcurrentIndexBuild): Promise<void>;
+  /** Drops an index without blocking its table's reads and writes; never inside a transaction. */
+  dropIndexConcurrently?(name: string): Promise<void>;
 }
 
 export const QUERY_OPERATOR_KEYS = queryOperatorKeys;
@@ -275,6 +280,8 @@ export interface SqlDialect {
   orderTerm(expr: string, direction: 1 | -1): string;
   indexName(name: string): string;
   createIndex(props: CreateIndexProps): string;
+  /** Rows `{ name, valid }`, one per index on `table` besides its primary key. */
+  indexesOf(table: string): SqlFrag;
   applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
   /** The stored document with these top-level fields replaced (value as JSON text) and these removed. */
   mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;

package/service/serviceModule.ts

@@ -202,6 +202,9 @@ export class ServiceModel<
       [`removeOne${key}`]: async function (this: DatabaseService, ...args: any) {
         return this.__removeOne(queryOf(args));
       },
+      [`purge${key}`]: async function (this: DatabaseService, ...args: any) {
+        return this.__purgeMany(queryOf(args));
+      },
       [`update${key}`]: function (this: DatabaseService, ...args: any): UpdateChain {
         const query = queryOf(args);
         return { set: (update) => this.__updateMany(query, update) };

package/service/types.ts

@@ -105,6 +105,7 @@ export type DatabaseService<
   __remove: (id: string) => Promise<Doc>;
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
   __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __purgeMany: (query: _QueryOfDoc) => Promise<number>;
   __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;

package/types/document/database.d.ts

@@ -55,6 +55,8 @@ type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends a
     [K in `remove${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
 } & {
     [K in `removeOne${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+    [K in `purge${CapitalizedK}`]: (...args: _Args) => Promise<number>;
 } & {
     [K in `update${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
 } & {
@@ -83,6 +85,7 @@ export type DatabaseInstanceWithQuerySort<T extends string = string, Input = any
     __remove: (id: string) => Promise<Doc>;
     __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
     __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+    __purgeMany: (query: _QueryOfDoc) => Promise<number>;
     __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
     __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
     __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;

package/types/document/into.d.ts

@@ -55,6 +55,8 @@ export type Mdl<Doc, Raw, _RawDoc = DocumentModel<Raw>, _RawQuery extends Docume
     updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>, options?: DocumentScopeOptions): Promise<UpdateResult>;
     removeOne(query: _RawQuery): Promise<UpdateResult>;
     removeMany(query: _RawQuery): Promise<UpdateResult>;
+    /** Deletes every row the query matches, removed ones too, and answers how many: no hook, cascade or undo. */
+    purgeMany(query: _RawQuery): Promise<number>;
     updateById(id: string, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
     removeById(id: string): Promise<UpdateResult>;
     /**

package/types/fetch/fetchType/endpointFetch.type.d.ts

@@ -1,7 +1,7 @@
 import type { ENDPOINT_META, PromiseOrObject } from "akanjs/base";
 import type { FetchPolicy } from "akanjs/common";
 import type { EndpInfoArgs, EndpInfoClientReturns, EndpInfoNullable, EndpInfoReqType, EndpointCls, EndpointInfo, PromptMessage, SlceCnstFull, SlceCnstInsight, SlceCnstLight, SliceCls } from "akanjs/signal";
-type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = ClientReturns extends (infer R)[] ? ExtendedEndpointReturn<R, Full, Light, Insight>[] : Full extends ClientReturns ? Full : Light extends ClientReturns ? Light : Insight extends ClientReturns ? Insight : ClientReturns;
+type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = unknown extends ClientReturns ? ClientReturns : ClientReturns extends (infer R)[] ? ExtendedEndpointReturn<R, Full, Light, Insight>[] : Full extends ClientReturns ? Full : Light extends ClientReturns ? Light : Insight extends ClientReturns ? Insight : ClientReturns;
 type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] extends [never] ? EndpInfoClientReturns<E> : ExtendedEndpointReturn<EndpInfoClientReturns<E>, SlceCnstFull<SlceCls>, SlceCnstLight<SlceCls>, SlceCnstInsight<SlceCls>>;
 type OrNull<T, Nullable> = Nullable extends true ? T | null : T;
 type EndpInfoReturns<E, SlceCls extends SliceCls | never> = OrNull<EndpointClientReturns<E, SlceCls>, EndpInfoNullable<E>>;

package/types/service/predefinedAdaptor/database.adaptor.d.ts

@@ -40,6 +40,11 @@ export declare class SqliteDatabase extends SqliteDatabase_base implements Datab
     getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqlDocumentStore;
     getMeta(key: string): string | undefined;
     setMeta(key: string, value: string): Promise<void>;
+    listMeta(prefix: string): {
+        key: string;
+        value: string;
+    }[];
+    deleteMeta(key: string): Promise<void>;
     transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
     afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
     checkpoint(mode?: "PASSIVE" | "FULL" | "RESTART" | "TRUNCATE"): void;
@@ -71,10 +76,16 @@ export declare class PostgresDatabase extends PostgresDatabase_base implements D
     getStore(constant: ConstantModel, database: DatabaseModel, schema: SchemaOf): SqlDocumentStore;
     getMeta(key: string): Promise<string | undefined>;
     setMeta(key: string, value: string): Promise<void>;
+    listMeta(prefix: string): Promise<{
+        key: string;
+        value: string;
+    }[]>;
+    deleteMeta(key: string): Promise<void>;
     transaction<T>(fn: () => PromiseOrObject<T>): Promise<T>;
     afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
     lockSchema<T>(fn: () => Promise<T>): Promise<T>;
     hasTable(table: string): Promise<boolean>;
     hasValidIndex(name: string): Promise<boolean>;
     buildIndexConcurrently({ name, next, create, replace }: ConcurrentIndexBuild): Promise<void>;
+    dropIndexConcurrently(name: string): Promise<void>;
 }

package/types/service/predefinedAdaptor/sql/SqlDocumentStore.d.ts

@@ -50,6 +50,7 @@ export declare class SqlDocumentStore {
         modifiedCount: number;
         upsertedId: any;
     }>;
+    purgeManyByQuery(query: DocumentQuery): Promise<number>;
     private compiledUpdate;
     bulkWrite(operations: {
         updateOne: {

package/types/service/predefinedAdaptor/sql/dialect/postgres.d.ts

@@ -30,6 +30,7 @@ export declare class PostgresDialect implements SqlDialect {
     orderTerm(expr: string, direction: 1 | -1): string;
     indexName(name: string): string;
     createIndex({ name, table, unique, columns, concurrently, where }: CreateIndexProps): string;
+    indexesOf(table: string): SqlFrag;
     applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
     mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;
     affectedRows(result: unknown): number;

package/types/service/predefinedAdaptor/sql/dialect/sqlite.d.ts

@@ -25,6 +25,7 @@ export declare class SqliteDialect implements SqlDialect {
     orderTerm(expr: string, direction: 1 | -1): string;
     indexName(name: string): string;
     createIndex({ name, table, unique, columns, where }: CreateIndexProps): string;
+    indexesOf(table: string): SqlFrag;
     applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
     mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;
     affectedRows(result: unknown): number;

package/types/service/predefinedAdaptor/sql/types.d.ts

@@ -68,6 +68,7 @@ export interface DocumentStore {
         modifiedCount: number;
         upsertedId: string | null;
     }>;
+    purgeManyByQuery(query: DocumentQuery): Promise<number>;
     bulkWrite(operations: {
         updateOne: {
             filter: DocumentQuery;
@@ -197,6 +198,14 @@ export interface DocumentDatabaseOwner {
     getSearchIndex(): SearchIndex | null;
     getMeta(key: string): Promise<string | undefined> | string | undefined;
     setMeta(key: string, value: string): Promise<void>;
+    listMeta(prefix: string): Promise<{
+        key: string;
+        value: string;
+    }[]> | {
+        key: string;
+        value: string;
+    }[];
+    deleteMeta(key: string): Promise<void>;
     afterCommit(fn: () => PromiseOrObject<void>): Promise<void>;
     transaction?<T>(fn: () => PromiseOrObject<T>): Promise<T>;
     /** Runs `fn` as the only schema change: Postgres races two `CREATE … IF NOT EXISTS` into a duplicate-key error. */
@@ -207,6 +216,8 @@ export interface DocumentDatabaseOwner {
     grantInsight?(table: string): Promise<void>;
     /** Builds an index on a table that already holds rows without blocking its writes; never inside a transaction. */
     buildIndexConcurrently?(build: ConcurrentIndexBuild): Promise<void>;
+    /** Drops an index without blocking its table's reads and writes; never inside a transaction. */
+    dropIndexConcurrently?(name: string): Promise<void>;
 }
 export declare const QUERY_OPERATOR_KEYS: Set<string>;
 export interface SqlFrag {
@@ -270,6 +281,8 @@ export interface SqlDialect {
     orderTerm(expr: string, direction: 1 | -1): string;
     indexName(name: string): string;
     createIndex(props: CreateIndexProps): string;
+    /** Rows `{ name, valid }`, one per index on `table` besides its primary key. */
+    indexesOf(table: string): SqlFrag;
     applyUpdate(acc: string, op: DocumentUpdateOperator, path: string, value: unknown): SqlFrag;
     /** The stored document with these top-level fields replaced (value as JSON text) and these removed. */
     mergeDocument(set: [field: string, json: string][], removed: string[]): SqlFrag;

package/types/service/types.d.ts

@@ -33,6 +33,7 @@ export type DatabaseService<T extends string = string, Input = any, Doc = any, O
     __remove: (id: string) => Promise<Doc>;
     __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
     __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+    __purgeMany: (query: _QueryOfDoc) => Promise<number>;
     __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
     __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
     __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;

package/types/ui/Model/editSeed.d.ts

@@ -0,0 +1,4 @@
+export declare class EditSeed {
+    #private;
+    static keyOf(edit: Record<string, unknown>, modelObjKey: string, viewAtKey: string): string;
+}

package/ui/Model/EditModal.tsx

@@ -14,6 +14,7 @@ import type { ModalSurfaceProps } from "../Dialog/modalSurface";
 import { Modal } from "../Modal";
 import DraftBar from "./DraftBar";
 import { type DraftProp, editDraftScope, newDraftScope } from "./draftScope";
+import { EditSeed } from "./editSeed";
 import { NewFormOrigin } from "./newFormOrigin";
 
 const EDIT_PAYLOAD_MAX_AGE_MS = 60_000;
@@ -206,10 +207,15 @@ export default function EditModal<Full extends { id: string }>({
       Date.now() - viewAt.getTime() > EDIT_PAYLOAD_MAX_AGE_MS
     );
   }, []);
+  const filledSeedRef = useRef<string | null>(null);
   useEffect(() => {
     if (!modelEdit) return;
     const refName = (modelEdit as ServerEdit<string, Full>).refName;
     const editType: "edit" | "new" = refName && (modelEdit as DynamicRecord)[names.modelObj] ? "edit" : "new";
+    const seedKey = EditSeed.keyOf(modelEdit as DynamicRecord, names.modelObj, names.modelViewAt);
+    
+    if (seedKey === filledSeedRef.current && (st.get() as unknown as DynamicRecord)[names.modelModal]) return;
+    filledSeedRef.current = seedKey;
     const cnst = ConstantRegistry.getDatabase(modelName);
     const modelRef = cnst.full;
     if (editType === "edit") {

package/ui/Model/editSeed.ts

@@ -0,0 +1,28 @@
+import { deepObjectify } from "akanjs/common";
+
+export class EditSeed {
+  static keyOf(edit: Record<string, unknown>, modelObjKey: string, viewAtKey: string): string {
+    const modelObj = edit[modelObjKey] as { id: string; updatedAt?: unknown } | undefined;
+    if (edit.refName && modelObj)
+      
+      return `edit:${modelObj.id}@${EditSeed.#timeOf(modelObj.updatedAt) ?? EditSeed.#timeOf(edit[viewAtKey])}`;
+    return `new:${EditSeed.#stableStringify(deepObjectify(edit, { serializable: true, convertDate: "string" }))}`;
+  }
+
+  static #timeOf(value: unknown): number | null {
+    if (value === null || value === undefined) return null;
+    const time = new Date(value as string).getTime();
+    return Number.isNaN(time) ? null : time;
+  }
+
+  static #stableStringify(value: unknown): string {
+    if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+    if (Array.isArray(value)) return `[${value.map((item) => EditSeed.#stableStringify(item)).join(",")}]`;
+    const source = value as Record<string, unknown>;
+    const entries = Object.keys(source)
+      .filter((key) => source[key] !== undefined)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${EditSeed.#stableStringify(source[key])}`);
+    return `{${entries.join(",")}}`;
+  }
+}

package/ui/Tab/Provider.tsx

@@ -147,14 +147,12 @@ export interface PanelProps {
 }
 export const Panel = ({ className, menu, children, loading = "eager" }: PanelProps) => {
   const { menu: currentMenu } = useContext(TabContext);
-  const [loaded, setLoaded] = useState(menu === currentMenu);
-
+  const isShown = currentMenu === menu;
+  const [loaded, setLoaded] = useState(isShown);
+  const isMounted = loading === "eager" || isShown || (loading === "lazy" && loaded);
   useEffect(() => {
-    if (loading === "eager") setLoaded(true);
-    else if (loading === "lazy" && !loaded && currentMenu === menu) setLoaded(true);
-    else if (loading === "every") setLoaded(currentMenu === menu);
-  }, [currentMenu]);
+    setLoaded(isMounted);
+  }, [isMounted]);
 
-  if (loading === "eager") return <div className={cn(className, currentMenu !== menu && "hidden")}>{children}</div>;
-  else return loaded ? <div className={cn(className, currentMenu !== menu && "hidden")}>{children}</div> : null;
+  return isMounted ? <div className={cn(className, !isShown && "hidden")}>{children}</div> : null;
 };