Sylvain Duchesne
ae9c32e271
Two batches, verified against nextgraph-rs throughout. P1a — the capability surface. Reading was an ACL (Map<doc, Set<principal>>), the exact inversion of key possession. It is now possession: `capFor(nuri)` is the only question, there is no principal parameter anywhere, and nothing turns a bare reference into a cap. Sharing is `shareCap(cap, toInbox)`, a Link deposit; receiving needs no operation. `Nuri` and `ReadCap` are template literal types, so passing a bare reference where a cap belongs is a compile error, with runtime guards behind it for JavaScript callers. The virtual user boundary. Every access function is now confined to the connected user, through two rules on one criterion (possession), implemented in two places so a lapse in either is caught by the other: authorization at the passage points, and "do not even attempt" at the callers. The polyfill's own machinery moved to physical.ts — unguarded, never exported — which replaced an exemption list: the machinery no longer gets waved through the guard, it calls something the guard never saw. Removed, as emulating capabilities the target does not have: - discovery.ts and its global index. There is no discovery in NextGraph; you follow links. It also pooled user data across wallets. - the cross-account fan-out (listEntityDocs, resolveReadGraphs, allAccounts, loadShim), which was cross-user enumeration by construction. - resolveInboxAnchor, a single inbox common to every user. Caps are now stored where NextGraph stores them, and read back rather than recomputed: AddRepo on the store's Store branch for documents a user creates, AddLink on its User branch for caps received. Inboxes belong to someone — the user's own, plus one per document — and connecting a user drains them all; that is the library's job, not the app's. Corrections worth recording: a ReadCap is `r:`, not `:k:` (reported by NextGraph's developer, verified in BlockRef::readcap_nuri); received caps DO have a register (AddLink), contrary to what this repo's notes claimed; and "wallet" upstream means keyring — what owns three stores is a user, so the vocabulary follows. The cap value is the constant OK: the only question the emulation answers is whether a cap is held. P1b replaces that one constant with a real key. After this the shape is right and the isolation is still fake. Nothing here may be described as anonymous or private.
56 lines
2.7 KiB
TypeScript
56 lines
2.7 KiB
TypeScript
/**
|
|
* @ng-eventually/client — **SDK-identical** surface.
|
|
*
|
|
* This entry exposes ONLY what `@ng-org/web` / `@ng-org/orm` expose (current +
|
|
* anticipated: `inbox`). Import `ng` / `useShape` from here instead of the SDK
|
|
* during the polyfill period; at migration the build alias is removed and these
|
|
* resolve to the real SDK with **no code change**.
|
|
*
|
|
* The one non-SDK piece — the polyfill bootstrap (`configure`, capability
|
|
* helpers, current user) — lives at `@ng-eventually/client/polyfill`, and is the
|
|
* only thing removed at migration.
|
|
*/
|
|
|
|
export * from "./types";
|
|
export { useShape } from "./use-shape";
|
|
export { watchShape } from "./watch-shape";
|
|
export type { ShapeQuery, ShapeObservable } from "./watch-shape";
|
|
export { init, initNg } from "./lifecycle";
|
|
export * as inbox from "./inbox";
|
|
export * as docs from "./docs";
|
|
export { subscribeDoc, subscribeDocs, docChangeType } from "./subscribe";
|
|
export type { DocChange, DocChangeType, Unsubscribe } from "./subscribe";
|
|
export * as readModel from "./read-model";
|
|
export type { UnionSubject } from "./read-model";
|
|
export * as storeRegistry from "./store-registry";
|
|
export type { AccountRecord, RegistrySession } from "./store-registry";
|
|
export * as accounts from "./accounts";
|
|
export type { AccountStorage } from "./accounts";
|
|
|
|
// SPARQL injection-safety helpers — so the app can reuse the same escaping /
|
|
// validation when it builds SPARQL by interpolation. `escapeLiteral` for string
|
|
// literals, `escapeIri` to embed untrusted values in an IRI, `assertNuri` to
|
|
// validate trusted-shaped NURIs before embedding them in an IRI.
|
|
export { escapeLiteral, escapeIri, assertNuri } from "./sparql";
|
|
|
|
// NURI type guards — the doors through which an app's own `string` (read back
|
|
// from storage, a URL, JSON, a form) becomes a typed `Nuri` or `ReadCap`. `Nuri`
|
|
// and `ReadCap` are template literal types, so an app that narrows with these
|
|
// gets the same compile-time distinction the library uses internally — in
|
|
// particular, it cannot pass a bare reference where a cap is required. Narrow
|
|
// with these rather than casting: a cast re-opens exactly the confusion the
|
|
// types exist to close.
|
|
export { isNuri, hasReadCap } from "./nuri";
|
|
|
|
// SDK type re-exports — so the app imports these from @ng-eventually/client too,
|
|
// not from @ng-org. `export type` is ERASED at build, so this adds NO runtime
|
|
// @ng-org import to the lib (no risk of a duplicate SDK copy in the bundle).
|
|
export type { ShapeType, BaseType, Schema } from "@ng-org/shex-orm";
|
|
export type { DeepSignalSet } from "@ng-org/alien-deepsignals";
|
|
export type { NG } from "@ng-org/web";
|
|
|
|
import { makeNg } from "./ng-proxy";
|
|
|
|
/** SDK-identical `ng` (wrapped). Drop-in replacement for `@ng-org/web`'s `ng`. */
|
|
export const ng: Record<string, any> = makeNg();
|