@ai-matrx/records 0.58.117 → 0.58.118

package/dist/core/index.d.cts

@@ -102,6 +102,25 @@ declare function intersectIds(sets: Uuid[][]): Uuid[];
  */
 declare const A_PERSONS_REFUSAL: ReadonlySet<RecordsErrorCode>;
 declare function isAPersonsRefusal(code: RecordsErrorCode | string): boolean;
+/** One organization the client could not use, with the sentence that says why. */
+interface OrganizationUnavailable {
+    organization_id: Uuid;
+    reason: string;
+}
+/** `organizationsOpen`: the organizations whose store answers, and those that do not (with why). */
+interface OrganizationsOpenAnswer {
+    open: Uuid[];
+    unavailable: OrganizationUnavailable[];
+}
+/** `metadataSearch`: every match, each carrying the organization it came from. */
+interface MetadataSearchAnswer {
+    matches: Array<Record<string, unknown> & {
+        organization_id: Uuid | null;
+    }>;
+    /** Organizations asked in order (the ones that answered). */
+    organizations_covered: Uuid[];
+    unavailable: OrganizationUnavailable[];
+}
 interface RecordsClient {
     /** The config this client was built with, so a screen can show who it is acting as. */
     readonly config: RecordsConfig;
@@ -1167,6 +1186,13 @@ interface RecordsClient {
      */
     recordAggregate(args: {
         table_id: Uuid;
+        /**
+         * OPTIONAL FILTER (active-org law): with `config.organizationIds` set, the table is looked
+         * up across all the person's organizations and the aggregate runs in the one that OWNS it
+         * (each row then carries that `organization_id`); this narrows the lookup to one. Absent and
+         * no `organizationIds` ⇒ this client's own organization, exactly as before.
+         */
+        organization_id?: Uuid | null;
         /** Field keys whose values become the groups. */
         groupBy?: string[];
         /** `count` needs no key; every other operation reads one Field. */
@@ -1516,9 +1542,37 @@ interface RecordsClient {
         record_id: Uuid;
         organization_id?: Uuid | null;
     }): Promise<RecordsResult<ReadValue[]>>;
+    /**
+     * Metadata search across EVERY organization the person belongs to (`config.organizationIds`;
+     * `organization_id` narrows to one). Each match carries its own `organization_id`; an
+     * organization whose store is off or refuses is listed in `unavailable` WITH its reason and
+     * never hides the rest. Only when NO organization answers is the whole search a failure (the
+     * first refusal). The door itself is not in the store's catalogue yet, so today every
+     * organization refuses in the door-absent sentence — named, never faked.
+     */
     metadataSearch(args: {
         text: string;
-    }): Promise<RecordsResult<never>>;
+        organization_id?: Uuid | null;
+    }): Promise<RecordsResult<MetadataSearchAnswer>>;
+    /**
+     * WHICH of the person's organizations can this client use right now? Asks every organization
+     * in scope (`organization_id` narrows to one) whether its record store is open, so a host can
+     * say "organization X is unavailable: <reason>" instead of silently dropping it. Organization
+     * order is the person's own, never completion order.
+     */
+    organizationsOpen(args?: {
+        organization_id?: Uuid | null;
+    }): Promise<RecordsResult<OrganizationsOpenAnswer>>;
+    /**
+     * The organization that OWNS a table or record — the one a write to it must run in. A
+     * `table_id` is looked up across all the person's organizations; a `record_id` is opened in its
+     * own. `null` = found in none of them. Never a permission: the store's doors still decide.
+     */
+    ownerOrganization(args: {
+        table_id?: Uuid | null;
+        record_id?: Uuid | null;
+        organization_id?: Uuid | null;
+    }): Promise<RecordsResult<Uuid | null>>;
     /**
      * Mint an embed token. `mode` is `read` OR `write` and never both — the store
      * refuses a token carrying two decisions. The secret comes back ONCE, because

package/dist/core/index.d.ts

@@ -102,6 +102,25 @@ declare function intersectIds(sets: Uuid[][]): Uuid[];
  */
 declare const A_PERSONS_REFUSAL: ReadonlySet<RecordsErrorCode>;
 declare function isAPersonsRefusal(code: RecordsErrorCode | string): boolean;
+/** One organization the client could not use, with the sentence that says why. */
+interface OrganizationUnavailable {
+    organization_id: Uuid;
+    reason: string;
+}
+/** `organizationsOpen`: the organizations whose store answers, and those that do not (with why). */
+interface OrganizationsOpenAnswer {
+    open: Uuid[];
+    unavailable: OrganizationUnavailable[];
+}
+/** `metadataSearch`: every match, each carrying the organization it came from. */
+interface MetadataSearchAnswer {
+    matches: Array<Record<string, unknown> & {
+        organization_id: Uuid | null;
+    }>;
+    /** Organizations asked in order (the ones that answered). */
+    organizations_covered: Uuid[];
+    unavailable: OrganizationUnavailable[];
+}
 interface RecordsClient {
     /** The config this client was built with, so a screen can show who it is acting as. */
     readonly config: RecordsConfig;
@@ -1167,6 +1186,13 @@ interface RecordsClient {
      */
     recordAggregate(args: {
         table_id: Uuid;
+        /**
+         * OPTIONAL FILTER (active-org law): with `config.organizationIds` set, the table is looked
+         * up across all the person's organizations and the aggregate runs in the one that OWNS it
+         * (each row then carries that `organization_id`); this narrows the lookup to one. Absent and
+         * no `organizationIds` ⇒ this client's own organization, exactly as before.
+         */
+        organization_id?: Uuid | null;
         /** Field keys whose values become the groups. */
         groupBy?: string[];
         /** `count` needs no key; every other operation reads one Field. */
@@ -1516,9 +1542,37 @@ interface RecordsClient {
         record_id: Uuid;
         organization_id?: Uuid | null;
     }): Promise<RecordsResult<ReadValue[]>>;
+    /**
+     * Metadata search across EVERY organization the person belongs to (`config.organizationIds`;
+     * `organization_id` narrows to one). Each match carries its own `organization_id`; an
+     * organization whose store is off or refuses is listed in `unavailable` WITH its reason and
+     * never hides the rest. Only when NO organization answers is the whole search a failure (the
+     * first refusal). The door itself is not in the store's catalogue yet, so today every
+     * organization refuses in the door-absent sentence — named, never faked.
+     */
     metadataSearch(args: {
         text: string;
-    }): Promise<RecordsResult<never>>;
+        organization_id?: Uuid | null;
+    }): Promise<RecordsResult<MetadataSearchAnswer>>;
+    /**
+     * WHICH of the person's organizations can this client use right now? Asks every organization
+     * in scope (`organization_id` narrows to one) whether its record store is open, so a host can
+     * say "organization X is unavailable: <reason>" instead of silently dropping it. Organization
+     * order is the person's own, never completion order.
+     */
+    organizationsOpen(args?: {
+        organization_id?: Uuid | null;
+    }): Promise<RecordsResult<OrganizationsOpenAnswer>>;
+    /**
+     * The organization that OWNS a table or record — the one a write to it must run in. A
+     * `table_id` is looked up across all the person's organizations; a `record_id` is opened in its
+     * own. `null` = found in none of them. Never a permission: the store's doors still decide.
+     */
+    ownerOrganization(args: {
+        table_id?: Uuid | null;
+        record_id?: Uuid | null;
+        organization_id?: Uuid | null;
+    }): Promise<RecordsResult<Uuid | null>>;
     /**
      * Mint an embed token. `mode` is `read` OR `write` and never both — the store
      * refuses a token carrying two decisions. The secret comes back ONCE, because

package/dist/core/index.js

@@ -40784,6 +40784,13 @@ function createRecordsClient(config) {
     }
     return last;
   }
+  const spans = (filter) => Boolean(filter) || (config.organizationIds?.length ?? 0) > 0;
+  const metadataSearchDoor = () => {
+    const refusal = doorAbsent(DOORS.metadataSearch);
+    scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "metadataSearch" });
+    return err(refusal);
+  };
+  const unavailableReason = (error) => `${error.message}${error.hint ? ` ${error.hint}` : ""}`;
   const client = {
     config,
     async recordWrite({ table_id, data }) {
@@ -42113,7 +42120,23 @@ function createRecordsClient(config) {
         "dashboardDelete"
       );
     },
-    async recordAggregate({ table_id, groupBy, measures, bucket, filter, limit, compare }) {
+    async recordAggregate({ table_id, organization_id, groupBy, measures, bucket, filter, limit, compare }) {
+      if (spans(organization_id)) {
+        const owner = await client.ownerOrganization({ table_id, ...organization_id ? { organization_id } : {} });
+        const target = owner.ok && owner.data ? owner.data : organization_id ?? org;
+        if (target !== org) {
+          const answered = await clientFor(target).recordAggregate({
+            table_id,
+            ...groupBy ? { groupBy } : {},
+            ...measures ? { measures } : {},
+            ...bucket !== void 0 ? { bucket } : {},
+            ...filter ? { filter } : {},
+            ...limit !== void 0 ? { limit } : {},
+            ...compare !== void 0 ? { compare } : {}
+          });
+          return answered.ok ? ok(answered.data.map((row) => ({ ...row, organization_id: target }))) : answered;
+        }
+      }
       return callDoor(
         DOORS.recordAggregate,
         {
@@ -43029,10 +43052,80 @@ function createRecordsClient(config) {
         "ruleDeclare"
       );
     },
-    async metadataSearch() {
-      const refusal = doorAbsent(DOORS.metadataSearch);
-      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "metadataSearch" });
-      return err(refusal);
+    async metadataSearch({ text, organization_id }) {
+      if (spans(organization_id) && readOrgs(organization_id).length > 0) {
+        const targets = readOrgs(organization_id).filter((t) => t !== null);
+        const unavailable = [];
+        const answers = await Promise.all(
+          targets.map(async (t) => {
+            const sub = clientFor(t);
+            const open = await sub.storeIsOpen();
+            if (!open.ok) {
+              unavailable.push({ organization_id: t, reason: unavailableReason(open.error) });
+              return null;
+            }
+            if (!open.data) {
+              unavailable.push({ organization_id: t, reason: "The custom data store is switched off for this organization." });
+              return null;
+            }
+            const found = metadataSearchDoor();
+            if (!found.ok) {
+              unavailable.push({ organization_id: t, reason: unavailableReason(found.error) });
+              return { t, found };
+            }
+            return { t, found };
+          })
+        );
+        const matches = [];
+        const covered = [];
+        let firstRefusal = null;
+        for (const answer of answers) {
+          if (!answer) continue;
+          if (!answer.found.ok) {
+            firstRefusal ??= answer.found.error;
+            continue;
+          }
+          covered.push(answer.t);
+          for (const m of answer.found.data.matches) matches.push({ ...m, organization_id: answer.t });
+        }
+        const inOrder = (a, b) => targets.indexOf(a.organization_id) - targets.indexOf(b.organization_id);
+        unavailable.sort(inOrder);
+        if (covered.length === 0 && firstRefusal) return err(firstRefusal);
+        return ok({ matches, organizations_covered: covered, unavailable });
+      }
+      return metadataSearchDoor();
+    },
+    async organizationsOpen(args) {
+      const targets = readOrgs(args?.organization_id).filter((t) => t !== null);
+      const open = [];
+      const unavailable = [];
+      await Promise.all(
+        targets.map(async (t) => {
+          const result = await clientFor(t).storeIsOpen();
+          if (!result.ok) unavailable.push({ organization_id: t, reason: unavailableReason(result.error) });
+          else if (!result.data)
+            unavailable.push({ organization_id: t, reason: "The custom data store is switched off for this organization." });
+          else open.push(t);
+        })
+      );
+      const position = (id) => targets.indexOf(id);
+      open.sort((a, b) => position(a) - position(b));
+      unavailable.sort((a, b) => position(a.organization_id) - position(b.organization_id));
+      return ok({ open, unavailable });
+    },
+    async ownerOrganization({ table_id, record_id, organization_id }) {
+      if (table_id) {
+        const read = await client.tableRead({ table_id, ...organization_id ? { organization_id } : {} });
+        if (!read.ok) return err(read.error);
+        return ok(read.data ? read.data.organization_id ?? null : null);
+      }
+      if (record_id) {
+        const read = await client.recordRead({ record_id, ...organization_id ? { organization_id } : {} });
+        if (!read.ok) return ok(null);
+        const targets = readOrgs(organization_id);
+        return ok(recordOrgs.get(record_id) ?? organization_id ?? (targets.length === 1 ? targets[0] ?? null : null));
+      }
+      return ok(null);
     },
     async fieldPropose() {
       const refusal = doorAbsent(DOORS.fieldPropose);