@haverstack/core 0.40.0 → 0.42.0

package/dist/stack/stack.d.ts

@@ -0,0 +1,438 @@
+/**
+ * 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, RecordChangeSet, 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, DeleteAndReturnResult, DeleteRecordOptions, DeleteResult, GetRecordOptions, MigrateAllOptions, StackClient, StackOptions } from './client.js';
+import type { ExpectationOptions } from './write-expectation.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.mutate(...)` 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;
+    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>;
+    /**
+     * Apply a change set as one atomic write — see StackClient.mutate(). A
+     * set the record already satisfies writes nothing, and content is checked
+     * against the record's current stored type.
+     * See docs/spec/data-model.md § Mutations.
+     */
+    mutate(id: RecordId, changes: RecordChangeSet, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * mutate() with `contentPatch` alone. The common case by a wide margin,
+     * and named for what it does rather than for a symmetry with create()
+     * that a patch does not have.
+     */
+    patchContent(id: RecordId, patch: Record<string, unknown | null>, opts?: IfVersionOptions & ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Every check a change set owes, all before anything is written. Returns
+     * the merged content for a content patch, which the caller compares to
+     * decide whether content moved. A parent is checked only when it changes.
+     */
+    private validateChangeSet;
+    /**
+     * Add associations to a record, without a version bump. One matching an
+     * existing association's identity but a different `attachmentRecordId`
+     * re-points it in place. See docs/spec/attachments.md § Naming the upload
+     * a reference came from.
+     */
+    associate(id: RecordId, associations: DataAssociation[], opts?: ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Remove associations from a record — see associate(). Matched by kind,
+     * label and payload; an element not found is a no-op. The emitted event
+     * names each association by identity only, since an attachment's
+     * `attachmentRecordId` describes nothing current once it is gone; the
+     * journal is where it survives.
+     */
+    dissociate(id: RecordId, associations: DataAssociation[], opts?: ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * The atomic form of associate() and dissociate(): one list of adds and
+     * removes, one adapter write, one journal entry. The journal records each
+     * element in full — a remove with its annotation, a re-point with what it
+     * overwrote — so the entry is as undoable as a single-element one.
+     * See docs/spec/data-model.md § Mutations.
+     */
+    amendAssociations(id: RecordId, changes: AssociationEdit[], opts?: ActorOptions & ExpectationOptions, surface?: string): Promise<StackRecord>;
+    /**
+     * Extend who reaches a record. The spelling that survives two admins
+     * sharing a record at once: a `permissions` key write replaces the whole
+     * set, so the later of two concurrent ones drops what the earlier
+     * granted. No-bump, like associate(); an element the record already
+     * carries is a no-op. `write` never implies `read` — name both.
+     */
+    grantAccess(id: RecordId, permissions: AuthorityAssociation[], opts?: ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * Withdraw elements of who reaches a record — see grantAccess() for why
+     * this is a verb rather than a key write. An element the record does not
+     * carry is a no-op. Returns the record as it now stands.
+     */
+    revokeAccess(id: RecordId, permissions: AuthorityAssociation[], opts?: ActorOptions & ExpectationOptions): Promise<StackRecord>;
+    /**
+     * The atomic form of grantAccess() and revokeAccess(). The
+     * write-implies-read invariant is asked once, of the set the whole list
+     * produces. See docs/spec/access-control.md § Write implies read.
+     */
+    amendAccess(id: RecordId, changes: AssociationEdit[], opts?: ActorOptions & ExpectationOptions, surface?: string): Promise<StackRecord>;
+    /**
+     * 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;
+    /**
+     * 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. A purge reports
+     * the files the record referenced, deleting none of them. Use
+     * deleteAndReturn() when the record is needed too. 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>;
+    /**
+     * delete(), plus the record it acted on — before destruction for a purge,
+     * the tombstone for a soft delete — captured inside the same write, so no
+     * concurrent write can land unseen between a read and the delete.
+     */
+    deleteAndReturn(id: RecordId, opts?: DeleteRecordOptions & ActorOptions & ExpectationOptions): Promise<DeleteAndReturnResult>;
+    /**
+     * 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,
+     * resolved against registered Types. 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>;
+    /**
+     * Resolve filter.baseId into a concrete typeId set (intersected with
+     * filter.typeId when both are given), so adapters never need their own
+     * baseId concept. Returns EMPTY_FAMILY when the resolved set is empty so
+     * the caller can short-circuit without an adapter round trip.
+     */
+    private resolveBaseIdFilter;
+    /**
+     * Every registered version of the named families, as concrete typeIds —
+     * resolved here because an adapter has no baseId concept of its own.
+     */
+    private familyTypeIds;
+    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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"}