@noy-db/hub 0.3.0-pre.9 → 0.3.0

package/dist/chunk-QJR3W3MF.js

@@ -1,23 +0,0 @@
-// src/with-audit/guards/read-only-facade.ts
-var ReadOnlyVaultFacade = class {
-  _vault;
-  _layer;
-  constructor(vault, layer = "read") {
-    this._vault = vault;
-    this._layer = layer;
-  }
-  collection(name) {
-    const c = this._vault.collection(name);
-    const layer = this._layer;
-    return {
-      get: (id) => c.get(id, { _layer: layer }),
-      list: () => c.list({ _layer: layer }),
-      query: () => c.query()
-    };
-  }
-};
-
-export {
-  ReadOnlyVaultFacade
-};
-//# sourceMappingURL=chunk-QJR3W3MF.js.map

package/dist/chunk-QJR3W3MF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/with-audit/guards/read-only-facade.ts"],"sourcesContent":["import type { Vault } from '../../kernel/vault.js'\nimport type { Query } from '../../kernel/query/builder.js'\nimport type { Layer } from '../../shape/via-i18n/policy.js'\nimport type { ReadOnlyVaultFacade as ReadOnlyVaultFacadeContract } from './types.js'\n\n/**\n * Minimal read-only wrapper over a `Vault`. Used as `ctx.vault` inside\n * guard / derivation callbacks so they can fetch related records without\n * acquiring any write capability.\n *\n * The `layer` tags every `get`/`list` read with the resolution layer it\n * belongs to. A guard-seeded facade reads at `'guard'`, a\n * derivation-seeded one at `'derivation'`, so i18nText / dictKey fields\n * resolve under that layer's `onMissing` policy instead of the `'read'`\n * policy — e.g. a guard read can `substitute` a missing locale (lenient\n * default) while the same field `throw`s on an ordinary app read.\n *\n * `query()` is left untagged: the query/aggregate pipeline reads raw\n * `{locale}` maps (no resolution call site), so a layer tag there would be\n * inert. Routing `mv`/`join` resolution through the pipeline is tracked\n * separately.\n */\nexport class ReadOnlyVaultFacade implements ReadOnlyVaultFacadeContract {\n  private readonly _vault: Vault\n  private readonly _layer: Layer\n\n  constructor(vault: Vault, layer: Layer = 'read') {\n    this._vault = vault\n    this._layer = layer\n  }\n\n  collection<T = unknown>(name: string): {\n    get(id: string): Promise<T | null>\n    list(): Promise<T[]>\n    query(): Query<T>\n  } {\n    const c = this._vault.collection<T>(name)\n    const layer = this._layer\n    return {\n      get: (id: string) => c.get(id, { _layer: layer }),\n      list: () => c.list({ _layer: layer }),\n      query: () => c.query(),\n    }\n  }\n}\n"],"mappings":";AAsBO,IAAM,sBAAN,MAAiE;AAAA,EACrD;AAAA,EACA;AAAA,EAEjB,YAAY,OAAc,QAAe,QAAQ;AAC/C,SAAK,SAAS;AACd,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,WAAwB,MAItB;AACA,UAAM,IAAI,KAAK,OAAO,WAAc,IAAI;AACxC,UAAM,QAAQ,KAAK;AACnB,WAAO;AAAA,MACL,KAAK,CAAC,OAAe,EAAE,IAAI,IAAI,EAAE,QAAQ,MAAM,CAAC;AAAA,MAChD,MAAM,MAAM,EAAE,KAAK,EAAE,QAAQ,MAAM,CAAC;AAAA,MACpC,OAAO,MAAM,EAAE,MAAM;AAAA,IACvB;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-QTXQ6RNZ.js

@@ -1,255 +0,0 @@
-import {
-  hasExportCapability,
-  hasImportCapability
-} from "./chunk-6CU3FN74.js";
-import {
-  ExportCapabilityError,
-  ImportCapabilityError
-} from "./chunk-CU62BBRB.js";
-
-// src/port/with/capabilities.ts
-function assertCanExport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) {
-      throw new Error("vault.assertCanExport: plaintext tier requires a format");
-    }
-    if (!hasExportCapability(keyring, "plaintext", format)) {
-      throw new ExportCapabilityError({
-        tier: "plaintext",
-        userId: keyring.userId,
-        format
-      });
-    }
-    return;
-  }
-  if (!hasExportCapability(keyring, "bundle")) {
-    throw new ExportCapabilityError({
-      tier: "bundle",
-      userId: keyring.userId
-    });
-  }
-}
-function assertCanImport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) {
-      throw new Error("vault.assertCanImport: plaintext tier requires a format");
-    }
-    if (!hasImportCapability(keyring, "plaintext", format)) {
-      throw new ImportCapabilityError({
-        tier: "plaintext",
-        userId: keyring.userId,
-        format
-      });
-    }
-    return;
-  }
-  if (!hasImportCapability(keyring, "bundle")) {
-    throw new ImportCapabilityError({
-      tier: "bundle",
-      userId: keyring.userId
-    });
-  }
-}
-function canExport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) return false;
-    return hasExportCapability(keyring, "plaintext", format);
-  }
-  return hasExportCapability(keyring, "bundle");
-}
-function canImport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) return false;
-    return hasImportCapability(keyring, "plaintext", format);
-  }
-  return hasImportCapability(keyring, "bundle");
-}
-
-// src/port/with/write-hooks.ts
-var WriteHookRegistry = class {
-  #before = [];
-  #after = [];
-  #suppressed = false;
-  /** True while handlers are running — used by the write path to skip nested firing. */
-  get suppressed() {
-    return this.#suppressed;
-  }
-  /** True when any hook is registered (cheap gate for the write path). */
-  get hasHandlers() {
-    return this.#before.length > 0 || this.#after.length > 0;
-  }
-  onBeforeWrite(handler) {
-    this.#before.push(handler);
-    return () => {
-      const i = this.#before.indexOf(handler);
-      if (i >= 0) this.#before.splice(i, 1);
-    };
-  }
-  onAfterWrite(handler) {
-    this.#after.push(handler);
-    return () => {
-      const i = this.#after.indexOf(handler);
-      if (i >= 0) this.#after.splice(i, 1);
-    };
-  }
-  /** Run before-hooks (awaited, in order). A throw propagates and aborts the write. */
-  async runBefore(event) {
-    if (this.#before.length === 0) return;
-    this.#suppressed = true;
-    try {
-      for (const h of this.#before.slice()) await h(event);
-    } finally {
-      this.#suppressed = false;
-    }
-  }
-  /** Run after-hooks (awaited, in order). Per-handler errors are warned, not thrown. */
-  async runAfter(event) {
-    if (this.#after.length === 0) return;
-    this.#suppressed = true;
-    try {
-      for (const h of this.#after.slice()) {
-        try {
-          await h(event);
-        } catch (err) {
-          console.warn(
-            `[noy-db] onAfterWrite handler failed for ${event.collection}/${event.docId}: ` + (err instanceof Error ? err.message : String(err))
-          );
-        }
-      }
-    } finally {
-      this.#suppressed = false;
-    }
-  }
-};
-
-// src/port/with/service-bus.ts
-var ServiceBus = class {
-  #handlers = /* @__PURE__ */ new Map();
-  #gateHandlers = /* @__PURE__ */ new Map();
-  #depth = 0;
-  /** Register a handler for an observe point. Returns an unsubscribe fn. */
-  register(point, handler) {
-    let arr = this.#handlers.get(point);
-    if (!arr) {
-      arr = [];
-      this.#handlers.set(point, arr);
-    }
-    arr.push(handler);
-    return () => {
-      const a = this.#handlers.get(point);
-      if (!a) return;
-      const i = a.indexOf(handler);
-      if (i >= 0) a.splice(i, 1);
-    };
-  }
-  /** Cheap gate for the write path — true when any handler is registered for the point. */
-  hasHandlers(point) {
-    const a = this.#handlers.get(point);
-    return a !== void 0 && a.length > 0;
-  }
-  /**
-   * True while one or more dispatches are in flight. Backed by a depth counter
-   * so that two concurrent async dispatches (`Promise.all([put('a'), put('b')])`
-   * each captured `busAfterPut=true` at their respective put() tops while depth
-   * was 0) both proceed independently — the counter stays > 0 until BOTH finish,
-   * so any nested write attempted by a handler still sees `dispatching === true`
-   * and is suppressed by the write-path gate in `collection.ts`
-   * (`busAfterPut = hasHandlers('afterPut') && !dispatching`). Re-entrancy
-   * suppression lives exclusively on that write-path gate; concurrent independent
-   * dispatches must not drop each other's events.
-   */
-  get dispatching() {
-    return this.#depth > 0;
-  }
-  /**
-   * Dispatch in registration order, awaited. Per-handler errors are warned, not
-   * thrown — an observe handler must never abort a completed write. A
-   * re-entrancy guard suppresses nested firing so a handler that itself writes
-   * cannot loop (same rationale as WriteHookRegistry.#suppressed).
-   */
-  async dispatch(point, event) {
-    const a = this.#handlers.get(point);
-    if (!a || a.length === 0) return;
-    this.#depth++;
-    try {
-      for (const h of a.slice()) {
-        try {
-          await h(event);
-        } catch (err) {
-          console.warn(
-            `[noy-db] service observe handler failed at ${point}: ` + (err instanceof Error ? err.message : String(err))
-          );
-        }
-      }
-    } finally {
-      this.#depth--;
-    }
-  }
-  /**
-   * Register a write-gating handler. A throw from the handler ABORTS the
-   * write. Returns an unsubscribe fn. See {@link GateRegisterOptions} for
-   * the `needsPrior` prior-read declaration (#267).
-   */
-  registerGate(point, handler, opts) {
-    let arr = this.#gateHandlers.get(point);
-    if (!arr) {
-      arr = [];
-      this.#gateHandlers.set(point, arr);
-    }
-    const entry = { fn: handler, needsPrior: opts?.needsPrior !== false };
-    arr.push(entry);
-    return () => {
-      const a = this.#gateHandlers.get(point);
-      if (!a) return;
-      const i = a.indexOf(entry);
-      if (i >= 0) a.splice(i, 1);
-    };
-  }
-  /** Cheap gate for the write path — true when any gate handler is registered for the point. */
-  hasGateHandlers(point) {
-    const a = this.#gateHandlers.get(point);
-    return a !== void 0 && a.length > 0;
-  }
-  /**
-   * True when at least one gate handler at `point` needs the prior record
-   * (the default). False when the point has no handlers or every handler
-   * registered with `needsPrior: false` — the write path then skips the
-   * prior-read before dispatching (#267 prior-read elision).
-   */
-  gateNeedsPrior(point) {
-    const a = this.#gateHandlers.get(point);
-    if (!a) return false;
-    return a.some((e) => e.needsPrior);
-  }
-  /**
-   * Run gate handlers in registration order, awaited. Unlike `dispatch`
-   * (observe), a handler throw is NOT swallowed — it PROPAGATES, aborting the
-   * write before it reaches the store. The first throw stops the remaining
-   * handlers (fail-fast). This is the seam guards/periods migrate onto.
-   *
-   * Note: gate handlers are validators that read, not write. A gate handler
-   * that writes back into the same collection would re-enter the write path
-   * and re-dispatch this point; loop-suppression for that case is deferred to
-   * the migration slice (contract: gate handlers must not perform writes that
-   * re-trigger their own point).
-   */
-  async dispatchGate(point, event) {
-    const a = this.#gateHandlers.get(point);
-    if (!a || a.length === 0) return;
-    for (const e of a.slice()) {
-      await e.fn(event);
-    }
-  }
-};
-var SubsystemBus = ServiceBus;
-
-export {
-  assertCanExport,
-  assertCanImport,
-  canExport,
-  canImport,
-  WriteHookRegistry,
-  ServiceBus,
-  SubsystemBus
-};
-//# sourceMappingURL=chunk-QTXQ6RNZ.js.map