@powerhousedao/reactor-attachments 6.0.0-dev.208

package/dist/index.d.ts

@@ -0,0 +1,442 @@
+import { Kysely } from "kysely";
+import { AttachmentHash, AttachmentRef, JwtHandler } from "@powerhousedao/reactor";
+
+//#region src/errors.d.ts
+/**
+ * Thrown when an attachment ref or hash is not known to the store.
+ */
+declare class AttachmentNotFound extends Error {
+  constructor(identifier: string);
+}
+/**
+ * Thrown when a reservation ID is not found in the reservation store.
+ */
+declare class ReservationNotFound extends Error {
+  constructor(reservationId: string);
+}
+/**
+ * Thrown when an attachment ref string does not match the expected format.
+ */
+declare class InvalidAttachmentRef extends Error {
+  constructor(ref: string);
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Status of attachment data in the local store.
+ */
+type AttachmentStatus = "available" | "evicted";
+/**
+ * Metadata about an attachment. Only exists after data is stored
+ * (via upload.send for client uploads, or put for sync).
+ */
+type AttachmentHeader = {
+  hash: AttachmentHash;
+  mimeType: string;
+  fileName: string;
+  sizeBytes: number;
+  extension: string | null;
+  status: AttachmentStatus;
+  source: "local" | "sync";
+  createdAtUtc: string;
+  lastAccessedAtUtc: string;
+};
+/**
+ * Metadata provided alongside attachment data during sync.
+ * The remaining fields (hash, status, source, createdAtUtc, lastAccessedAtUtc)
+ * are set by the store when it creates the attachment record.
+ */
+type AttachmentMetadata = {
+  mimeType: string;
+  fileName: string;
+  sizeBytes: number;
+  extension: string | null;
+};
+/**
+ * Options provided when reserving an attachment slot.
+ */
+type ReserveAttachmentOptions = {
+  mimeType: string;
+  fileName: string;
+  extension?: string | null;
+};
+/**
+ * Result of uploading attachment data through a handle.
+ */
+type AttachmentUploadResult = {
+  hash: AttachmentHash;
+  ref: AttachmentRef;
+  header: AttachmentHeader;
+};
+/**
+ * Response when retrieving attachment data from the local store.
+ */
+type AttachmentResponse = {
+  header: AttachmentHeader;
+  body: ReadableStream<Uint8Array>;
+};
+/**
+ * Response when fetching attachment data from a remote transport.
+ * Lighter than AttachmentResponse -- a remote peer cannot meaningfully
+ * populate status or source, which are local reactor concerns.
+ * The store assigns those fields when it calls put() on receipt.
+ */
+type TransportResponse = {
+  hash: AttachmentHash;
+  metadata: AttachmentMetadata;
+  body: ReadableStream<Uint8Array>;
+};
+/**
+ * Configuration for creating an attachment transport instance.
+ */
+type AttachmentTransportConfig = {
+  type: string;
+  parameters: Record<string, unknown>;
+};
+/**
+ * A reservation for an in-progress attachment upload.
+ * Created by reserve(), deleted when upload.send() completes.
+ */
+type Reservation = {
+  reservationId: string;
+  mimeType: string;
+  fileName: string;
+  extension: string | null;
+  createdAtUtc: string;
+};
+//#endregion
+//#region src/interfaces.d.ts
+/**
+ * Client-facing interface for uploading, querying, and retrieving attachments.
+ * This is what applications (editors, Connect, CLI tools) interact with.
+ */
+interface IAttachmentService {
+  /**
+   * Reserve a new attachment slot and return an upload handle.
+   *
+   * The handle abstracts the transport -- the caller streams data
+   * through it without knowing whether bytes flow via HTTP, S3,
+   * or any other mechanism.
+   */
+  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
+  /**
+   * Get attachment metadata by ref.
+   *
+   * @throws AttachmentNotFound if the ref is unknown.
+   */
+  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
+  /**
+   * Retrieve attachment data.
+   *
+   * Always succeeds for any known ref. The underlying store handles
+   * re-fetching evicted data from the transport transparently.
+   */
+  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
+}
+/**
+ * Upload handle returned by reserve(). Encapsulates all transport-specific
+ * concerns (URLs, credentials, streaming protocols) behind a single send() method.
+ */
+interface IAttachmentUpload {
+  /**
+   * Unique identifier for this reservation.
+   */
+  reservationId: string;
+  /**
+   * Stream attachment data through this handle.
+   *
+   * The handle manages the full upload lifecycle internally:
+   * writing bytes to the backing store, computing or verifying
+   * the content hash, creating the attachment record, and
+   * cleaning up the reservation.
+   *
+   * Dedup: if an attachment with the same content hash already
+   * exists, send() returns the existing ref. Content-addressed
+   * storage means identical uploads converge on the same hash.
+   *
+   * @returns The content hash, ref, and header for the uploaded attachment.
+   */
+  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
+}
+/**
+ * Reactor-facing interface for managing local attachment data.
+ * The IAttachmentTransport calls put when it receives data from a remote.
+ * The store notifies its configured transport when new data arrives,
+ * forming a bidirectional store-transport pair.
+ */
+interface IAttachmentStore {
+  /**
+   * Get attachment metadata without streaming body data.
+   * Does NOT update lastAccessedAtUtc -- this is a metadata check,
+   * not a data access.
+   *
+   * @throws AttachmentNotFound if the hash is unknown.
+   */
+  stat(hash: AttachmentHash): Promise<AttachmentHeader>;
+  /**
+   * Check whether attachment data is available locally.
+   * Returns true if the bytes can be served from this reactor's store
+   * without a transport round-trip. Does not trigger a remote fetch.
+   */
+  has(hash: AttachmentHash): Promise<boolean>;
+  /**
+   * Retrieve attachment header and data stream by hash.
+   * Updates lastAccessedAtUtc on access.
+   *
+   * If the data has been evicted, re-fetches it from the transport,
+   * restores it locally via put(), and returns the data. This makes
+   * eviction transparent to callers -- get() always succeeds for
+   * any known hash.
+   *
+   * @throws AttachmentNotFound if the hash is unknown (no metadata
+   *         record exists).
+   */
+  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
+  /**
+   * Store attachment data received from a remote (during sync or re-fetch).
+   * Called by IAttachmentTransport implementations during sync, and
+   * internally by get() when restoring evicted data.
+   *
+   * Behavior depends on existing state:
+   * - No existing row: INSERT with source='sync', status='available'.
+   * - Existing row with status='evicted': restore data, set status
+   *   to 'available'.
+   * - Existing row with status='available': no-op (dedup).
+   */
+  put(hash: AttachmentHash, metadata: AttachmentMetadata, data: ReadableStream<Uint8Array>): Promise<void>;
+  /**
+   * Evict attachment data to reclaim storage.
+   *
+   * Removes the local bytes and sets status to 'evicted'. The
+   * metadata record is retained so the hash is still known. If the
+   * data is needed again, the service fetches it via the transport.
+   *
+   * Eviction must not destroy data while a get() stream is in
+   * flight. Implementations must skip hashes with active readers
+   * (e.g. via a refcount or lease) and revisit them on the next
+   * GC pass.
+   *
+   * On immutable backends, this unpins/stops serving rather
+   * than deleting.
+   */
+  evict(hash: AttachmentHash): Promise<void>;
+  /**
+   * Get the total storage used by locally available attachment data.
+   * Used by the GC policy to decide when to evict.
+   */
+  storageUsed(): Promise<number>;
+}
+/**
+ * Transport for moving attachment data between reactors.
+ *
+ * Forms a bidirectional pair with IAttachmentStore. The store calls
+ * announce/push when new data arrives locally. The transport calls
+ * store.put() when data arrives from a remote.
+ */
+interface IAttachmentTransport {
+  /**
+   * Fetch attachment data by hash from a remote source.
+   *
+   * The transport resolves the hash to a data source (server endpoint,
+   * S3 presigned URL, etc.) and returns a stream.
+   *
+   * @param hash - Content hash of the attachment
+   * @param signal - Abort signal for cancellation
+   * @returns The attachment data with metadata, or null if not available.
+   *          Returns TransportResponse (not AttachmentResponse) because
+   *          remote peers cannot populate local concerns like status/source.
+   */
+  fetch(hash: AttachmentHash, signal?: AbortSignal): Promise<TransportResponse | null>;
+  /**
+   * Announce that this reactor has attachment data available.
+   *
+   * For server-centric transports, this may be a no-op (the server
+   * already has the data after upload).
+   */
+  announce(hash: AttachmentHash): Promise<void>;
+  /**
+   * Push attachment data to a specific remote.
+   *
+   * Used for eager replication strategies where the source reactor
+   * pushes data to known peers rather than waiting for pull requests.
+   *
+   * @param hash - Content hash of the attachment
+   * @param remote - Target remote identifier
+   * @param data - The attachment data stream
+   */
+  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
+}
+/**
+ * Factory for creating attachment transport instances.
+ * Mirrors IChannelFactory for operation sync.
+ */
+interface IAttachmentTransportFactory {
+  instance(config: AttachmentTransportConfig): IAttachmentTransport;
+}
+/**
+ * Store for managing attachment reservations.
+ * Reservations are transient records tracking in-progress uploads.
+ */
+interface IReservationStore {
+  create(options: ReserveAttachmentOptions): Promise<Reservation>;
+  get(reservationId: string): Promise<Reservation>;
+  delete(reservationId: string): Promise<void>;
+}
+/**
+ * Factory for creating transport-specific upload handles.
+ * The service calls this during reserve() to create a handle
+ * that knows how to stream bytes to the appropriate backend.
+ */
+interface IAttachmentUploadFactory {
+  createUpload(reservationId: string, options: ReserveAttachmentOptions): IAttachmentUpload;
+}
+//#endregion
+//#region src/attachment-service.d.ts
+declare class AttachmentService implements IAttachmentService {
+  private readonly store;
+  private readonly reservations;
+  private readonly uploadFactory;
+  constructor(store: IAttachmentStore, reservations: IReservationStore, uploadFactory: IAttachmentUploadFactory);
+  reserve(options: ReserveAttachmentOptions): Promise<IAttachmentUpload>;
+  stat(ref: AttachmentRef): Promise<AttachmentHeader>;
+  get(ref: AttachmentRef, signal?: AbortSignal): Promise<AttachmentResponse>;
+}
+//#endregion
+//#region src/ref.d.ts
+type ParsedRef = {
+  version: number;
+  hash: AttachmentHash;
+};
+declare function parseRef(ref: AttachmentRef): ParsedRef;
+declare function createRef(hash: AttachmentHash, version?: number): AttachmentRef;
+//#endregion
+//#region src/storage/kysely/types.d.ts
+interface AttachmentTable {
+  hash: string;
+  mime_type: string;
+  file_name: string;
+  size_bytes: number;
+  extension: string | null;
+  status: string;
+  storage_path: string;
+  source: string;
+  created_at_utc: string;
+  last_accessed_at_utc: string;
+}
+interface AttachmentReservationTable {
+  reservation_id: string;
+  mime_type: string;
+  file_name: string;
+  extension: string | null;
+  created_at_utc: string;
+}
+interface AttachmentDatabase {
+  attachment: AttachmentTable;
+  attachment_reservation: AttachmentReservationTable;
+}
+//#endregion
+//#region src/storage/kysely/attachment-store.d.ts
+declare class KyselyAttachmentStore implements IAttachmentStore {
+  private readonly db;
+  private readonly transport;
+  private readonly basePath;
+  private readonly activeReaders;
+  constructor(db: Kysely<AttachmentDatabase>, transport: IAttachmentTransport, basePath: string);
+  stat(hash: AttachmentHash): Promise<AttachmentHeader>;
+  has(hash: AttachmentHash): Promise<boolean>;
+  get(hash: AttachmentHash, signal?: AbortSignal): Promise<AttachmentResponse>;
+  put(hash: AttachmentHash, metadata: AttachmentMetadata, data: ReadableStream<Uint8Array>): Promise<void>;
+  evict(hash: AttachmentHash): Promise<void>;
+  storageUsed(): Promise<number>;
+  private acquireReader;
+  private releaseReader;
+  private hasActiveReaders;
+}
+//#endregion
+//#region src/storage/kysely/reservation-store.d.ts
+declare class KyselyReservationStore implements IReservationStore {
+  private readonly db;
+  constructor(db: Kysely<AttachmentDatabase>);
+  create(options: ReserveAttachmentOptions): Promise<Reservation>;
+  get(reservationId: string): Promise<Reservation>;
+  delete(reservationId: string): Promise<void>;
+}
+//#endregion
+//#region src/storage/migrations/migrator.d.ts
+declare const ATTACHMENT_SCHEMA = "attachments";
+interface MigrationResult {
+  success: boolean;
+  migrationsExecuted: string[];
+  error?: Error;
+}
+declare function runAttachmentMigrations(db: Kysely<any>, schema?: string): Promise<MigrationResult>;
+//#endregion
+//#region src/direct/direct-attachment-upload.d.ts
+declare class DirectAttachmentUpload implements IAttachmentUpload {
+  private readonly options;
+  private readonly db;
+  private readonly basePath;
+  private readonly reservations;
+  readonly reservationId: string;
+  constructor(reservationId: string, options: ReserveAttachmentOptions, db: Kysely<AttachmentDatabase>, basePath: string, reservations: IReservationStore);
+  send(data: ReadableStream<Uint8Array>): Promise<AttachmentUploadResult>;
+}
+//#endregion
+//#region src/direct/direct-attachment-upload-factory.d.ts
+declare class DirectAttachmentUploadFactory implements IAttachmentUploadFactory {
+  private readonly db;
+  private readonly basePath;
+  private readonly reservations;
+  constructor(db: Kysely<AttachmentDatabase>, basePath: string, reservations: IReservationStore);
+  createUpload(reservationId: string, options: ReserveAttachmentOptions): IAttachmentUpload;
+}
+//#endregion
+//#region src/switchboard/switchboard-attachment-transport.d.ts
+type SwitchboardTransportConfig = {
+  remoteUrl: string;
+  jwtHandler?: JwtHandler;
+  fetchFn?: typeof fetch;
+};
+declare class SwitchboardAttachmentTransport implements IAttachmentTransport {
+  private readonly remoteUrl;
+  private readonly jwtHandler?;
+  private readonly fetchFn;
+  constructor(config: SwitchboardTransportConfig);
+  fetch(hash: AttachmentHash, signal?: AbortSignal): Promise<TransportResponse | null>;
+  announce(_hash: AttachmentHash): Promise<void>;
+  push(hash: AttachmentHash, remote: string, data: ReadableStream<Uint8Array>): Promise<void>;
+  private buildHeaders;
+  private parseMetadataHeaders;
+}
+//#endregion
+//#region src/null-attachment-transport.d.ts
+/**
+ * No-op transport for deployments without remote sync.
+ * fetch() always returns null, announce() and push() are no-ops.
+ */
+declare class NullAttachmentTransport implements IAttachmentTransport {
+  fetch(): Promise<TransportResponse | null>;
+  announce(): Promise<void>;
+  push(): Promise<void>;
+}
+//#endregion
+//#region src/attachment-builder.d.ts
+type AttachmentBuildResult = {
+  service: AttachmentService;
+  store: KyselyAttachmentStore;
+  reservations: KyselyReservationStore;
+  uploadFactory: IAttachmentUploadFactory;
+};
+declare class AttachmentBuilder {
+  private readonly db;
+  private readonly storagePath;
+  private transport;
+  private customUploadFactory?;
+  constructor(db: Kysely<any>, storagePath: string);
+  withTransport(transport: IAttachmentTransport): this;
+  withUploadFactory(factory: IAttachmentUploadFactory): this;
+  build(): Promise<AttachmentBuildResult>;
+}
+//#endregion
+export { ATTACHMENT_SCHEMA, type AttachmentBuildResult, AttachmentBuilder, type AttachmentDatabase, type AttachmentHeader, type AttachmentMetadata, AttachmentNotFound, type AttachmentResponse, AttachmentService, type AttachmentStatus, type AttachmentTransportConfig, type AttachmentUploadResult, DirectAttachmentUpload, DirectAttachmentUploadFactory, type IAttachmentService, type IAttachmentStore, type IAttachmentTransport, type IAttachmentTransportFactory, type IAttachmentUpload, type IAttachmentUploadFactory, type IReservationStore, InvalidAttachmentRef, KyselyAttachmentStore, KyselyReservationStore, NullAttachmentTransport, type ParsedRef, type Reservation, ReservationNotFound, type ReserveAttachmentOptions, SwitchboardAttachmentTransport, type SwitchboardTransportConfig, type TransportResponse, createRef, parseRef, runAttachmentMigrations };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/interfaces.ts","../src/attachment-service.ts","../src/ref.ts","../src/storage/kysely/types.ts","../src/storage/kysely/attachment-store.ts","../src/storage/kysely/reservation-store.ts","../src/storage/migrations/migrator.ts","../src/direct/direct-attachment-upload.ts","../src/direct/direct-attachment-upload-factory.ts","../src/switchboard/switchboard-attachment-transport.ts","../src/null-attachment-transport.ts","../src/attachment-builder.ts"],"mappings":"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"}