@ai-matrx/records 0.52.0 → 0.53.0

package/dist/react/index.cjs

@@ -130,6 +130,7 @@ __export(react_exports, {
   useRecordsActor: () => useRecordsActor,
   useRecordsClient: () => useRecordsClient,
   useTable: () => useTable,
+  useTableArchive: () => useTableArchive,
   useTables: () => useTables
 });
 module.exports = __toCommonJS(react_exports);
@@ -819,6 +820,7 @@ var STORE_DOORS = [
   { name: "stamp_value_envelopes", args: "p_data jsonb, p_actor text, p_on_behalf_of text, p_at timestamp with time zone", returns: "jsonb", security: "invoker" },
   { name: "storage_modes", args: "", returns: "text[]", security: "invoker" },
   { name: "store_is_open", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "boolean", security: "invoker" },
+  { name: "store_off_sentence", args: "p_organization_id uuid", returns: "text", security: "invoker" },
   { name: "subscription_cadences", args: "p_organization_id uuid", returns: "text[]", security: "definer" },
   { name: "subscription_declare", args: "p_organization_id uuid, p_table_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
   { name: "subscription_mute", args: "p_organization_id uuid, p_rule_id uuid, p_muted boolean DEFAULT true", returns: "boolean", security: "definer" },
@@ -2096,6 +2098,19 @@ var DOORS = {
   fieldOptions: "field_options",
   parityValues: "parity_values",
   tableDeclare: "table_declare",
+  // GETTING RID OF A TABLE — which is a JOB, NOT A STATEMENT (VERIFIER-11 F3).
+  // `record_delete` above is the store's one soft-delete door and it is right
+  // for a record; aimed at a TABLE it recurses through everything the Table
+  // contains inside one transaction, and that is unbounded by construction. A
+  // person pressing "Delete this table" on 1,430 records the product itself
+  // had just imported waited twelve seconds and was told `57014`, "canceling
+  // statement due to statement timeout … Nothing was changed. Try a smaller
+  // page" — advice that means nothing when what you are doing is getting rid
+  // of a table. `custom.table_archive` does the same work in passes and
+  // answers each one with numbers, so a screen shows a sentence and a count
+  // instead of a spinner and an SQLSTATE. It is STATELESS, so a run cut in
+  // half resumes exactly where it stopped: there is no job row to lose.
+  tableArchive: "table_archive",
   // ADDING A COLUMN — the first thing anybody does with a table, and until
   // 2026-09-19 there was no door for it. A Field is a record (REC-25), so a
   // screen wrote one with `record_write`; that door writes ONE row with
@@ -2751,6 +2766,18 @@ function createRecordsClient(config) {
         "recordRestore"
       );
     },
+    async tableArchive({ table_id, chunk, includeTable }) {
+      return callDoor(
+        DOORS.tableArchive,
+        {
+          p_organization_id: org,
+          p_table_id: table_id,
+          p_chunk: chunk ?? 50,
+          p_include_table: includeTable ?? true
+        },
+        "tableArchive"
+      );
+    },
     async recordRead({ record_id, withComputed = false }) {
       const door = await callDoor(
         DOORS.readRecord,
@@ -4822,6 +4849,85 @@ function useRecordMutation() {
     [client, run, saving, error, conflict]
   );
 }
+var MIN_ARCHIVE_CHUNK = 10;
+function useTableArchive(tableId, options) {
+  const client = useRecordsClient();
+  const chunk = options?.chunk ?? 50;
+  const includeTable = options?.includeTable ?? true;
+  const [progress, setProgress] = (0, import_react2.useState)(null);
+  const [running, setRunning] = (0, import_react2.useState)(false);
+  const [passes, setPasses] = (0, import_react2.useState)(0);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [interrupted, setInterrupted] = (0, import_react2.useState)(false);
+  const [chunkInUse, setChunkInUse] = (0, import_react2.useState)(chunk);
+  const [slowedDown, setSlowedDown] = (0, import_react2.useState)(false);
+  const cut = (0, import_react2.useRef)(false);
+  const preview = (0, import_react2.useCallback)(async () => {
+    setError(null);
+    const answered = await client.tableArchive({ table_id: tableId, chunk: 0, includeTable });
+    if (!answered.ok) {
+      setError(answered.error);
+      return null;
+    }
+    setProgress(answered.data);
+    return answered.data;
+  }, [client, tableId, includeTable]);
+  const loop = (0, import_react2.useCallback)(async () => {
+    cut.current = false;
+    setRunning(true);
+    setError(null);
+    setInterrupted(false);
+    setPasses(0);
+    let last = null;
+    let size = chunk;
+    setChunkInUse(size);
+    setSlowedDown(false);
+    try {
+      for (; ; ) {
+        const answered = await client.tableArchive({ table_id: tableId, chunk: size, includeTable });
+        if (!answered.ok) {
+          if (answered.error.code === "timed_out" && size > MIN_ARCHIVE_CHUNK) {
+            size = Math.max(MIN_ARCHIVE_CHUNK, Math.floor(size / 2));
+            setChunkInUse(size);
+            setSlowedDown(true);
+            continue;
+          }
+          setError(answered.error);
+          setInterrupted(true);
+          return last;
+        }
+        last = answered.data;
+        setProgress(answered.data);
+        setPasses((n) => n + 1);
+        if (answered.data.done) return answered.data;
+        if (cut.current) {
+          setInterrupted(true);
+          return answered.data;
+        }
+      }
+    } finally {
+      setRunning(false);
+    }
+  }, [client, tableId, chunk, includeTable]);
+  return (0, import_react2.useMemo)(
+    () => ({
+      progress,
+      running,
+      passes,
+      chunkInUse,
+      slowedDown,
+      error,
+      interrupted,
+      preview,
+      start: loop,
+      carryOn: loop,
+      stop: () => {
+        cut.current = true;
+      }
+    }),
+    [progress, running, passes, chunkInUse, slowedDown, error, interrupted, preview, loop]
+  );
+}
 function useEntityFields(token) {
   return useAsync(
     (client) => token ? client.entityFields({ token }) : Promise.resolve({ ok: true, data: [] }),