@haverstack/core 0.41.0 → 0.43.0

package/dist/stack/stack.d.ts

@@ -0,0 +1,444 @@
+/**
+ * Stack — Core Stack Class
+ * -------------------------------------------------------
+ * The Stack class is the primary interface for apps. It sits
+ * on top of a StackAdapter and adds:
+ *
+ *  - ID generation, and validation of every caller-supplied field
+ *  - Type definition, schema hashing and drift detection
+ *  - Content validation on write, and the integrity rules in integrity.ts
+ *  - Migrations: the registry, commitMigration() and owner-driven migrateAll()
+ *  - Version snapshots, the change journal, soft delete and purge
+ *  - Association and permission edits, and the change feed
+ *  - Attachments, type-level grants and app installs, whose bodies live
+ *    beside this file
+ *  - asEntity()/asActor(), the scoped views that enforce access control
+ *
+ * Apps should never talk to a StackAdapter directly.
+ */
+import type { StackRecord, StackType, TypeSchema, TypeId, BaseId, StackAdapter, StackQuery, QueryResult, AssociationEdit, AuthorityAssociation, DataAssociation, RecordVersion, StackCapabilities, IfVersionOptions, GrantContent, TypeGrant, PutAttachmentOptions, AttachmentContent, FileId, EntityId, AppId, InstallContent, RecordId, Actor, ActorOptions, RecordChange, SubscribeOptions, Unsubscribe, JournalQuery, VersionsQuery, RecordJournalEntry } from '../types/index.js';
+import type { GrantQuery } from '../grants.js';
+import type { AppManifest, InstallPlan } from '../install.js';
+import { ScopedStack } from '../scoped-stack/scoped-stack.js';
+import type { BackdatableCreateRecordOptions, CollectAttachmentGarbageOptions, CollectAttachmentGarbageResult, DefineTypeOptions, DeleteRecordOptions, DeleteResult, GetRecordOptions, MigrateAllOptions, StackClient, StackOptions } from './client.js';
+import type { ExpectationOptions } from './write-expectation.js';
+import type { GateOptions } from './write-gate.js';
+import type { ContentOf, ReadonlyTypeSchema, TypeHandle } from '../type-handle.js';
+import type { Collection } from '../collection.js';
+export declare class Stack implements StackClient {
+    private readonly adapter;
+    private readonly idTimestampSkewMsValue;
+    private readonly migrations;
+    /**
+     * Types this instance has fetched or defined, keyed by versioned id. A
+     * Type's schema is immutable once defined, so entries are never
+     * invalidated, only added; listTypes() refreshes wholesale. See
+     * docs/spec/data-model.md § Type cache.
+     */
+    private readonly typeCache;
+    /** Set by close(). See docs/spec/adapters.md § Lifecycle. */
+    private closed;
+    /**
+     * Every change made through this Stack. `ScopedStack` filters this same
+     * stream rather than opening its own, so no scoped view can observe a
+     * change the stack did not emit. See docs/spec/events.md.
+     */
+    private readonly changes;
+    private constructor();
+    /**
+     * Announce a mutation that has already been persisted. Called after the
+     * adapter write resolves and before the mutating method settles, so
+     * `await stack.patchContent(...)` guarantees subscribers have been notified —
+     * and nothing about work they deferred. A handler cannot fail the write:
+     * there is nothing left to fail. See docs/spec/events.md § Handlers.
+     */
+    private announce;
+    /**
+     * The actor for a `create` journal entry, read off the record as just
+     * built. Create is the one journaled write that stamps the requester
+     * onto the row itself, so the record in hand is authoritative — and it
+     * carries `appId`, which ActorOptions has no field for.
+     */
+    private static createActor;
+    private getTypeCached;
+    /**
+     * Open a Stack over an adapter. Reads ownerEntityId and timezone from the adapter.
+     */
+    static open(adapter: StackAdapter, opts?: StackOptions): Promise<Stack>;
+    /**
+     * Idempotent bootstrap for StackOptions.ownerProfile. Its probe sees every
+     * card the binding rules do, deleted and migrated ones included, or it
+     * would mint one they then refuse and the stack would not reopen.
+     * See docs/spec/identity.md § Entity.
+     */
+    private ensureOwnerEntity;
+    get ownerEntityId(): EntityId;
+    getEntityByDid(did: EntityId): Promise<StackRecord | null>;
+    getOwnerEntity(): Promise<StackRecord | null>;
+    get timezone(): string | undefined;
+    get capabilities(): StackCapabilities;
+    /**
+     * Get a permission-scoped view of this Stack, as if requests came from
+     * the given entity acting as itself (null = anonymous). Plain Stack
+     * methods are unscoped; use asEntity() when one Stack serves multiple,
+     * possibly untrusted, entities. See
+     * docs/spec/access-control.md § Enforcement: Stack.asEntity().
+     */
+    asEntity(entityId: EntityId | null): ScopedStack;
+    /**
+     * Scope to an Actor — a delegated app acting for its user, or a
+     * TokenSession as StackTokenStore.lookupToken() returns it, which is what
+     * a server should pass at its request boundary.
+     * See docs/spec/access-control.md § Delegation: principal and subject.
+     */
+    asActor(actor: Actor): ScopedStack;
+    /**
+     * A scoped view needs a stack that owns its storage: one whose adapter
+     * queries within a reach and relays no changes from elsewhere. A
+     * server-backed stack is scoped by the session that opened it instead.
+     * See docs/spec/access-control.md § Enforcement: Stack.asEntity().
+     */
+    private scope;
+    collection<S extends ReadonlyTypeSchema>(handle: TypeHandle<S>): Collection<ContentOf<S>>;
+    /**
+     * Define and persist a Type; call at app startup before creating records
+     * of the type. Redefining an existing typeId is checked against the
+     * stored schema: identical is a no-op, a name-only change persists, and
+     * anything beyond additive evolution throws StackSchemaDriftError. See
+     * docs/spec/data-model.md § Schema drift detection.
+     */
+    defineType({ id, name, schema: declared, migratesFrom, }: DefineTypeOptions): Promise<StackType>;
+    getType(id: TypeId): Promise<StackType | null>;
+    /** Refreshes typeCache wholesale — the explicit way to see a rename made by another writer. */
+    listTypes(): Promise<StackType[]>;
+    /**
+     * Check whether a record's type is compatible with a required schema.
+     * Useful for duck-typed consumption across types.
+     */
+    typeIsCompatible(typeId: TypeId, requiredSchema: TypeSchema): Promise<boolean>;
+    /**
+     * Migrate every record of a family, deleted ones included, to the latest
+     * version, aborting on the first that fails validation. `sweep: 'listed'`
+     * is for a contained app that cannot see unlisted or deleted content.
+     * See docs/spec/data-model.md § Type migrations.
+     */
+    migrateAll(baseId: BaseId, opts?: MigrateAllOptions): Promise<{
+        migrated: number;
+        skipped: number;
+    }>;
+    /**
+     * Create a record, validated against its type's schema. The one site that
+     * stamps a `_group`'s author as its first `admin`, for scoped creates too.
+     * Backdating is accepted unconditionally here; ScopedStack decides who may.
+     * See docs/spec/data-model.md § Backdating on import.
+     */
+    create<T extends Record<string, unknown> = Record<string, unknown>>(typeId: TypeId, input: T, opts?: BackdatableCreateRecordOptions): Promise<StackRecord & {
+        content: T;
+    }>;
+    /**
+     * Get a record by ID, exactly as stored — no implicit migration. Pass
+     * { presentAt: 'latest' } to migrate in memory; only migrateAll()
+     * commits migrations to disk. A soft-deleted record answers `null` unless
+     * { includeDeleted: true } is passed.
+     */
+    get(id: RecordId, opts?: GetRecordOptions): Promise<StackRecord | null>;
+    /**
+     * Merge a patch into a record's content, checked against its current
+     * stored type. A patch the content already satisfies writes nothing.
+     * See docs/spec/data-model.md § Mutations.
+     */
+    patchContent(id: RecordId, patch: Record<string, unknown | null>, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Every check a content patch owes, all before anything is written.
+     * Returns the merged content, which the caller compares to decide whether
+     * content moved.
+     */
+    private validatePatch;
+    /**
+     * Move a record under another, or to the root with `null`. The
+     * destination is checked only when it changes: it has to exist, and the
+     * move must not make the record its own ancestor.
+     * See docs/spec/data-model.md § Reparenting.
+     */
+    setParent(id: RecordId, parentId: RecordId | null, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Withhold a record from enumeration, or restore it. Restating the
+     * current state writes nothing, so `unlistedAt` is never dragged forward.
+     * See docs/spec/unlisted.md.
+     */
+    setUnlisted(id: RecordId, unlisted: boolean, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Apply adds and removes to a record's data associations: one adapter
+     * write, one journal entry carrying each element in full, so the entry is
+     * as undoable as a single-element one. An add naming a held identity with
+     * a new `attachmentRecordId` re-points it — see docs/spec/attachments.md
+     * § Naming the upload a reference came from.
+     */
+    editAssociations(id: RecordId, edits: AssociationEdit[], opts?: IfVersionOptions & ActorOptions & ExpectationOptions & GateOptions): Promise<StackRecord>;
+    /**
+     * Make a record's data associations exactly `associations`. Its
+     * permissions are another aspect, which this never reads or writes.
+     */
+    setAssociations(id: RecordId, associations: DataAssociation[], opts?: IfVersionOptions & ActorOptions & ExpectationOptions & GateOptions): Promise<StackRecord>;
+    /**
+     * The shared half of the two data-association writes, from the set the
+     * write would leave: nothing moved writes nothing, a roster keeps an
+     * admin, and every new attachment pointer names its own upload.
+     */
+    private writeAssociations;
+    /**
+     * Apply adds and removes to who reaches a record. The write-implies-read
+     * invariant is asked once, of the set the whole list produces, so a
+     * downgrade is one call. See docs/spec/access-control.md § Write implies read.
+     */
+    editAccess(id: RecordId, edits: AssociationEdit[], opts?: IfVersionOptions & ActorOptions & ExpectationOptions & GateOptions): Promise<StackRecord>;
+    /** Make who reaches a record exactly `permissions`; `[]` is private. */
+    setAccess(id: RecordId, permissions: AuthorityAssociation[], opts?: IfVersionOptions & ActorOptions & ExpectationOptions & GateOptions): Promise<StackRecord>;
+    private writeAccess;
+    /**
+     * Run an element-set write from its read onward, again from a fresh read
+     * each time the adapter finds the set moved since the last one, so the
+     * rules over the resulting set are asked of the set the write lands on.
+     * Unbounded: each refusal means another write landed.
+     * See docs/spec/versioning.md § Element-set writes compare the set they read.
+     */
+    private untilSetHolds;
+    /**
+     * Land a write that never bumps. Its precondition and journal entry
+     * travel together here, so no aspect verb can drop either.
+     */
+    private writeAspect;
+    /**
+     * Hold a permission set to the cross-element invariant — see
+     * validatePermissions() in access.ts for why it reads the post-state.
+     */
+    private assertPermissionSet;
+    /**
+     * A soft-deleted record has no current state to edit, so the verbs that
+     * edit one refuse it; undelete() and commitMigration() do not call this.
+     * Asked after the record is found and, under ScopedStack, after the
+     * authority decision. See docs/spec/versioning.md § Mutations are refused,
+     * not applied to a tombstone.
+     */
+    private refuseIfDeleted;
+    /**
+     * The record a write addresses, past every refusal owed before
+     * validation: missing, another family, a caller's gate, soft-deleted,
+     * then a stale `ifVersion` — before validation, so a caller that lost the
+     * race hears that first, and before any no-op, so a write that moved
+     * nothing never satisfies a precondition.
+     */
+    private requireWritable;
+    /**
+     * A by-id read straight from the adapter, for the integrity checks a write
+     * runs once it is under way: they read past the open-check, as the write
+     * they belong to was admitted before any close() began.
+     */
+    private readonly readRecord;
+    /** The record, or the not-found refusal every mutating verb owes. */
+    private requireRecord;
+    /**
+     * Soft-delete a record, or purge it with its history, reporting the
+     * record as the write left it — or as a purge destroyed it — captured in
+     * the same write, so nothing lands unseen between a read and the delete.
+     * See docs/spec/versioning.md § Deletion and docs/spec/attachments.md
+     * § A purge strands the bytes it referenced.
+     */
+    delete(id: RecordId, opts?: DeleteRecordOptions & ActorOptions & ExpectationOptions): Promise<DeleteResult>;
+    /**
+     * The files a record references, by the same definition
+     * deleteAttachment() and the garbage sweep use: attachment associations
+     * and top-level `file-ref` content fields. An `_attachment` record's own
+     * `fileId` is a plain string by design and is not one, which is why
+     * purging a metadata record reports nothing — see systemTypeDefinitions().
+     */
+    private referencedFileIds;
+    /**
+     * Reverse a soft delete. Idempotent — undeleting a record that isn't
+     * deleted returns it unchanged. Purged records are gone, so this
+     * throws StackNotFoundError for them just like any other missing record.
+     * Snapshots and bumps version, same as delete().
+     */
+    undelete(id: RecordId, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Query records. filter.baseId matches every version of a type family.
+     * Results come back exactly as stored; pass presentAt: 'latest' to
+     * migrate in memory. See docs/spec/data-model.md § Queries.
+     */
+    query(query?: StackQuery): Promise<QueryResult>;
+    /**
+     * Everything query() does around the adapter call once the query is
+     * split and checked: the migration on the way out. `read` is the call,
+     * so a scoped query within a reach gets the same treatment as any other.
+     */
+    private dispatchQuery;
+    getVersions(id: RecordId, query?: VersionsQuery): Promise<RecordVersion[]>;
+    /**
+     * A record's change journal, oldest first, ungated. A missing or purged
+     * record is StackNotFoundError, since a destroyed log and an empty one
+     * are not the same answer. See docs/spec/journal.md § Reading it.
+     */
+    getJournal(id: RecordId, query?: JournalQuery): Promise<RecordJournalEntry[]>;
+    getVersion(id: RecordId, version: number): Promise<RecordVersion | null>;
+    /**
+     * Restore a record to a previous version by creating a new version —
+     * never rewrites history. The snapshot is validated against its own
+     * stored typeId, and puts back `content` and `typeId` alone: a snapshot
+     * carries nothing else. See docs/spec/versioning.md § Restore semantics.
+     */
+    restoreVersion(id: RecordId, version: number, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Commit a per-record migration with caller-supplied content. Create-shaped
+     * at the destination and update-shaped over the record, so it owes both
+     * sets of integrity checks. See docs/spec/data-model.md § Type migrations.
+     */
+    commitMigration(id: RecordId, toTypeId: TypeId, content: Record<string, unknown>, opts?: IfVersionOptions & ActorOptions): Promise<StackRecord>;
+    /**
+     * The checked migration write behind commitMigration() and migrateAll(),
+     * taking the record in hand so a batch pass needs no re-read. A Migration
+     * function is held to the same checks as a request body: app code is no
+     * trust boundary here.
+     */
+    private commitMigrationChecked;
+    /**
+     * Store bytes and create their `_attachment@1` metadata record, returning
+     * it: `content.fileId` addresses the bytes, `id` the metadata. Uses the
+     * adapter's atomic putAttachmentWithMetadata() where there is one.
+     * See docs/spec/wire-format.md § Attachments.
+     */
+    putAttachment(data: Uint8Array, opts: PutAttachmentOptions): Promise<StackRecord & {
+        content: AttachmentContent;
+    }>;
+    getAttachment(fileId: FileId): Promise<Uint8Array>;
+    /**
+     * Every `_attachment` record describing `fileId`, earliest-recorded first.
+     * Not on StackClient: it presents an access decision already made, which
+     * a scoped version would only check a second, different way. See
+     * docs/spec/attachments.md § Finding a `fileId`'s metadata records.
+     */
+    getAttachmentRecords(fileId: FileId): Promise<(StackRecord & {
+        content: AttachmentContent;
+    })[]>;
+    /**
+     * Delete an attachment's bytes and every _attachment metadata record for
+     * it, family-wide. Throws StackConflictError if any record in the stack
+     * still references the file, StackNotFoundError if neither metadata
+     * records nor bytes exist.
+     */
+    deleteAttachment(fileId: FileId, opts?: ActorOptions): Promise<void>;
+    /**
+     * Sweep for attachment bytes unreachable from any record — live or
+     * soft-deleted — and delete bytes + metadata. Deletion goes through
+     * deleteAttachment(), so a file re-referenced by sweep time is skipped,
+     * not a failure. See docs/spec/attachments.md § Garbage collection.
+     */
+    collectAttachmentGarbage(opts?: CollectAttachmentGarbageOptions & ActorOptions): Promise<CollectAttachmentGarbageResult>;
+    /**
+     * Observe every change made through this Stack, unfiltered. Async so a
+     * remote stack resolves once its feed is live, making subscribe-then-query
+     * gap-free. See docs/spec/events.md § Subscribing.
+     */
+    subscribe(handler: (change: RecordChange) => void, opts?: SubscribeOptions): Promise<Unsubscribe>;
+    /**
+     * Ask the adapter to relay changes made elsewhere, if it can. One relay
+     * per subscription, carrying its filter to the far end, which holds the
+     * records that filter needs. See docs/spec/events.md § Where events come
+     * from.
+     */
+    private openRelay;
+    /** Whether changes reach this stack from elsewhere. */
+    private get relaysChanges();
+    /**
+     * Flush pending writes to the underlying storage. A no-op for adapters
+     * that commit on every call (SQLite, the API adapter); meaningful for
+     * ones that buffer, and for checkpointing a stack that stays open —
+     * close() covers the teardown case on its own.
+     */
+    flush(): Promise<void>;
+    /**
+     * Flush, then release any resources the adapter holds (connections, file
+     * handles, lock files). A failed flush still releases them before it
+     * propagates: an unwritable stack must not also leak a lock file.
+     * See docs/spec/adapters.md § Lifecycle.
+     */
+    close(): Promise<void>;
+    /** Throws once close() has run. */
+    private assertOpen;
+    /**
+     * Create a `_grant` authorizing `grantee` to take `actions` on `baseId`'s
+     * family. An app's `-own` is read as the bare verb when it acts for
+     * someone, so grant it the types it needs, not the narrowest-looking
+     * suffix. See docs/spec/access-control.md § Type-level grants.
+     */
+    grantType(baseId: BaseId, grant: TypeGrant): Promise<StackRecord & {
+        content: GrantContent;
+    }>;
+    /**
+     * List `_grant` records: all of them, or those `grantType()` would have
+     * written for the same grantee. The `entity` arm instead lists what
+     * currently applies to that entity, so it is not a preview of what
+     * `revokeType()` would withdraw. See docs/spec/access-control.md § Listing
+     * and revoking.
+     */
+    listTypeGrants(query?: GrantQuery): Promise<(StackRecord & {
+        content: GrantContent;
+    })[]>;
+    /**
+     * The inverse of grantType(): soft-deletes the matching `_grant` records,
+     * grantee and actions matched exactly, and returns them. Matching nothing
+     * is not an error, so re-running a revocation stays safe.
+     * See docs/spec/access-control.md § Listing and revoking.
+     */
+    revokeType(baseId: BaseId, grant: TypeGrant): Promise<(StackRecord & {
+        content: GrantContent;
+    })[]>;
+    /**
+     * What applying `manifest` for the key `did` would change, for the owner
+     * to review before installApp(). Writes nothing. Refuses outright what no
+     * approval could make valid: a type outside the app's own namespace and
+     * the commons, a request the grant rules refuse, or a `did` already
+     * registered to a different app. See docs/spec/apps.md § Plan, then apply.
+     */
+    planInstall(submitted: AppManifest, opts: {
+        did: EntityId;
+    }): Promise<InstallPlan>;
+    /**
+     * Apply an approved plan: types, the key's `_app` card, the `_install`
+     * Record and every linked key's grants. A plan the stack has moved on
+     * from is a StackConflictError, so what lands is what was approved.
+     * See docs/spec/apps.md § Plan, then apply.
+     */
+    installApp(plan: InstallPlan): Promise<StackRecord & {
+        content: InstallContent;
+    }>;
+    /**
+     * Withdraw every grant an install produced and soft-delete it. The app's
+     * records and `_app` cards stay: the data is the owner's, and the cards
+     * are what its records' attribution resolves through. Returns the
+     * install's tombstone. See docs/spec/apps.md § Uninstalling.
+     */
+    uninstallApp(appId: AppId): Promise<StackRecord & {
+        content: InstallContent;
+    }>;
+    /**
+     * Fast-fail for the ifVersion precondition using the already-fetched
+     * record. The adapter re-checks atomically at write time (the source of
+     * truth for concurrent writers) — this just skips validation and
+     * snapshotting work when the mismatch is already visible.
+     */
+    private checkIfVersion;
+    /**
+     * The options every version-bumping adapter write carries — precondition,
+     * prior-state snapshot and actor — taken together so a new verb cannot
+     * omit one. See docs/spec/versioning.md § Version history.
+     */
+    private writeOptions;
+    /**
+     * A record's prior state for the version it is about to leave: `content`
+     * and the `typeId` it is read under, which only a snapshot keeps. The
+     * journal keeps everything else. See docs/spec/versioning.md § Version
+     * history.
+     */
+    private buildVersionSnapshot;
+}
+//# sourceMappingURL=stack.d.ts.map

package/dist/stack/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../src/stack/stack.ts"],"names":[],"mappings":"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"}