@jolly-pixel/asset-server 1.0.0

package/dist/static/httpHandler.js

@@ -0,0 +1,105 @@
+// Import Node.js Dependencies
+import { Buffer } from "node:buffer";
+// Import Third-party Dependencies
+import { ASSET_URL_PREFIX } from "@jolly-pixel/asset";
+import { AssetPathEscapeError, isStatePath, safeAssetPath } from "@jolly-pixel/asset-source";
+import { contentTypesFromKinds, DEFAULT_CONTENT_TYPES, resolveContentType } from "./contentTypes.js";
+// CONSTANTS
+const kRejectionStatus = {
+    empty: 404,
+    directory: 404,
+    invalid: 400,
+    absolute: 403,
+    traversal: 403,
+    reserved: 403
+};
+export const DEFAULT_ASSET_PREFIX = ASSET_URL_PREFIX;
+export function createAssetStaticHandler(options) {
+    const { source, kinds, contentTypes } = options;
+    const prefix = withTrailingSlash(options.prefix ?? DEFAULT_ASSET_PREFIX);
+    const table = {
+        ...kinds ? contentTypesFromKinds(kinds) : DEFAULT_CONTENT_TYPES,
+        ...contentTypes
+    };
+    return function assetStaticHandler(request, response, next) {
+        const target = request.url ?? "";
+        if (!target.startsWith(prefix)) {
+            next();
+            return;
+        }
+        if (request.method !== "GET" &&
+            request.method !== "HEAD") {
+            response.statusCode = 405;
+            response.setHeader("allow", "GET, HEAD");
+            response.end();
+            return;
+        }
+        const requested = decodeRequestPath(target.slice(prefix.length));
+        if (requested === null) {
+            end(response, 400);
+            return;
+        }
+        const resolved = safeAssetPath(requested);
+        if (!resolved.ok) {
+            end(response, kRejectionStatus[resolved.val]);
+            return;
+        }
+        const assetPath = resolved.val;
+        if (isHidden(source, assetPath)) {
+            end(response, 404);
+            return;
+        }
+        void serve(source, assetPath, resolveContentType(assetPath, table), request, response);
+    };
+}
+async function serve(source, assetPath, contentType, request, response) {
+    let bytes;
+    try {
+        bytes = await source.read(assetPath);
+    }
+    catch (error) {
+        // The source rejects what its own containment check refuses, a symlink
+        // out of the root above all.
+        if (error instanceof AssetPathEscapeError) {
+            end(response, 403);
+            return;
+        }
+        end(response, isMissing(error) ? 404 : 500);
+        return;
+    }
+    response.statusCode = 200;
+    response.setHeader("content-type", contentType);
+    response.setHeader("content-length", String(bytes.byteLength));
+    response.end(request.method === "HEAD" ? undefined : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+}
+function decodeRequestPath(target) {
+    const separator = target.search(/[?#]/);
+    const encoded = separator === -1 ?
+        target :
+        target.slice(0, separator);
+    try {
+        return decodeURIComponent(encoded);
+    }
+    catch {
+        return null;
+    }
+}
+function isHidden(source, assetPath) {
+    return isStatePath(assetPath) ||
+        (source.isIgnored?.(assetPath) ?? false);
+}
+function isMissing(error) {
+    return typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ENOENT" ||
+            error.code === "EISDIR" ||
+            error.code === "ENOTDIR");
+}
+function end(response, statusCode) {
+    response.statusCode = statusCode;
+    response.end();
+}
+function withTrailingSlash(prefix) {
+    return prefix.endsWith("/") ? prefix : `${prefix}/`;
+}

package/dist/static/index.d.ts

@@ -0,0 +1,4 @@
+export { createAssetStaticHandler, DEFAULT_ASSET_PREFIX } from "./httpHandler.ts";
+export type { AssetStaticHandler, AssetStaticHandlerOptions } from "./httpHandler.ts";
+export { contentTypesFromKinds, resolveContentType, DEFAULT_CONTENT_TYPE, DEFAULT_CONTENT_TYPES } from "./contentTypes.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/static/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/static/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EAC1B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC"}

package/dist/static/index.js

@@ -0,0 +1,2 @@
+export { createAssetStaticHandler, DEFAULT_ASSET_PREFIX } from "./httpHandler.js";
+export { contentTypesFromKinds, resolveContentType, DEFAULT_CONTENT_TYPE, DEFAULT_CONTENT_TYPES } from "./contentTypes.js";

package/dist/sync/AssetProjector.d.ts

@@ -0,0 +1,33 @@
+import type * as EventStore from "@jolly-pixel/event-store";
+import type { AssetSource } from "@jolly-pixel/asset-source";
+import { type Logger } from "../logger.ts";
+import { type AssetProjection } from "./foldProjection.ts";
+import type { ProjectionState } from "./ProjectionState.ts";
+export interface AssetProjectorOptions {
+    source: AssetSource;
+    eventStore: EventStore.EventStore;
+    state: ProjectionState;
+    logger?: Logger;
+}
+/**
+ * Projects each asset's folded event stream into physical storage.
+ *
+ * Idempotent writes make stale checkpoints safe to replay.
+ */
+export declare class AssetProjector {
+    #private;
+    constructor(options: AssetProjectorOptions);
+    load(): void;
+    start(): void;
+    close(): Promise<void>;
+    projected(assetId: string): AssetProjection | null;
+    projections(): IterableIterator<{
+        assetId: string;
+        projection: AssetProjection;
+    }>;
+    desired(assetId: string): AssetProjection | null;
+    get pending(): number;
+    markProjected(assetId: string): void;
+    flush(assetId?: string): Promise<void>;
+}
+//# sourceMappingURL=AssetProjector.d.ts.map

package/dist/sync/AssetProjector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetProjector.d.ts","sourceRoot":"","sources":["../../src/sync/AssetProjector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,UAAU,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAG7D,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,cAAc,CAAC;AAWtB,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAS5D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC;IAClC,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,qBAAa,cAAc;;gBAavB,OAAO,EAAE,qBAAqB;IAQhC,IAAI,IAAI,IAAI;IAaZ,KAAK,IAAI,IAAI;IAUP,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,SAAS,CACP,OAAO,EAAE,MAAM,GACd,eAAe,GAAG,IAAI;IAIvB,WAAW,IAAI,gBAAgB,CAAC;QAChC,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,eAAe,CAAC;KAC7B,CAAC;IAQF,OAAO,CACL,OAAO,EAAE,MAAM,GACd,eAAe,GAAG,IAAI;IAIzB,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,aAAa,CACX,OAAO,EAAE,MAAM,GACd,IAAI;IAmBP,KAAK,CACH,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;CA8IjB"}

package/dist/sync/AssetProjector.js

@@ -0,0 +1,186 @@
+// Import Internal Dependencies
+import { silentLogger } from "../logger.js";
+import { ASSET_EVENT_PREFIX } from "../constants.js";
+import { ASSET_CHECKPOINT_EVENT_TYPES, decodeContent, describeRejection, parseAssetEvent } from "../events/AssetEvents.js";
+import { applyProjection } from "./foldProjection.js";
+import { TaskChain } from "../utils/TaskChain.js";
+/**
+ * Projects each asset's folded event stream into physical storage.
+ *
+ * Idempotent writes make stale checkpoints safe to replay.
+ */
+export class AssetProjector {
+    #source;
+    #eventStore;
+    #state;
+    #logger;
+    #folds = new Map();
+    #dirty = new Set();
+    #stateDirty = false;
+    #queue = new TaskChain();
+    #unsubscribe = null;
+    constructor(options) {
+        this.#source = options.source;
+        this.#eventStore = options.eventStore;
+        this.#state = options.state;
+        this.#logger = options.logger ?? silentLogger();
+    }
+    load() {
+        this.#folds.clear();
+        this.#dirty.clear();
+        const events = this.#eventStore.reader.listFromCheckpoints({
+            checkpointEventTypes: ASSET_CHECKPOINT_EVENT_TYPES,
+            eventTypePrefix: ASSET_EVENT_PREFIX
+        });
+        for (const event of events) {
+            this.#absorb(event);
+        }
+    }
+    start() {
+        this.#unsubscribe ??= this.#eventStore.subscribe((event) => {
+            this.#absorb(event);
+            void this.flush(event.assetId);
+        }, { eventTypePrefix: ASSET_EVENT_PREFIX });
+    }
+    async close() {
+        this.#unsubscribe?.();
+        this.#unsubscribe = null;
+        await this.flush();
+    }
+    projected(assetId) {
+        return this.#folds.get(assetId)?.projected ?? null;
+    }
+    *projections() {
+        for (const [assetId, fold] of this.#folds) {
+            if (fold.projected !== null) {
+                yield { assetId, projection: fold.projected };
+            }
+        }
+    }
+    desired(assetId) {
+        return this.#folds.get(assetId)?.desired ?? null;
+    }
+    get pending() {
+        return this.#dirty.size;
+    }
+    markProjected(assetId) {
+        const fold = this.#folds.get(assetId);
+        if (fold === undefined) {
+            this.#logger
+                .withMetadata({ assetId })
+                .warn("asset marked projected before its event was absorbed; " +
+                "is the projector started?");
+            return;
+        }
+        fold.projected = fold.desired;
+        this.#dirty.delete(assetId);
+        this.#state.advance(assetId, fold.desiredEventId);
+        this.#stateDirty = true;
+    }
+    flush(assetId) {
+        return this.#queue.run(() => this.#converge(assetId));
+    }
+    #absorb(event) {
+        const parsed = parseAssetEvent(event);
+        if (!parsed.ok) {
+            this.#reject(event, parsed.val);
+            return;
+        }
+        const assetEvent = parsed.val;
+        const fold = this.#folds.get(event.assetId) ?? {
+            projected: null,
+            desired: null,
+            desiredEventId: 0
+        };
+        fold.desired = applyProjection(fold.desired, assetEvent);
+        fold.desiredEventId = event.eventId;
+        if (event.eventId <= this.#state.checkpoint(event.assetId)) {
+            fold.projected = fold.desired;
+        }
+        else {
+            this.#dirty.add(event.assetId);
+        }
+        this.#folds.set(event.assetId, fold);
+    }
+    #reject(event, rejection) {
+        const log = this.#logger.withMetadata({
+            assetId: event.assetId,
+            eventId: event.eventId,
+            eventType: event.eventType,
+            reason: rejection.reason,
+            detail: describeRejection(rejection)
+        });
+        if (rejection.reason === "foreign") {
+            log.debug("unknown asset event skipped");
+            return;
+        }
+        log.warn("asset event skipped");
+    }
+    async #converge(assetId) {
+        const targets = assetId === undefined ?
+            [...this.#dirty] :
+            [assetId].filter((id) => this.#dirty.has(id));
+        for (const target of targets) {
+            await this.#convergeAsset(target);
+        }
+        if (this.#stateDirty) {
+            this.#stateDirty = false;
+            try {
+                await this.#state.save();
+            }
+            catch (error) {
+                this.#logger
+                    .withMetadata({
+                    reason: error instanceof Error ? error.message : String(error)
+                })
+                    .warn("projection state not persisted");
+            }
+        }
+    }
+    async #convergeAsset(assetId) {
+        const fold = this.#folds.get(assetId);
+        if (fold === undefined) {
+            this.#dirty.delete(assetId);
+            return;
+        }
+        const { projected, desired, desiredEventId } = fold;
+        try {
+            await this.#applyOperations(projected, desired);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.#state.recordFailure(assetId, desiredEventId, reason);
+            this.#stateDirty = true;
+            this.#logger
+                .withMetadata({ assetId, eventId: desiredEventId, reason })
+                .error("asset projection failed");
+            return;
+        }
+        fold.projected = desired;
+        this.#dirty.delete(assetId);
+        this.#state.advance(assetId, desiredEventId);
+        this.#stateDirty = true;
+        this.#logger
+            .withMetadata({
+            assetId,
+            eventId: desiredEventId,
+            path: desired?.path ?? projected?.path
+        })
+            .debug("asset projected");
+    }
+    async #applyOperations(projected, desired) {
+        if (desired === null) {
+            if (projected !== null) {
+                await this.#source.delete(projected.path);
+            }
+            return;
+        }
+        const moved = projected !== null && projected.path !== desired.path;
+        if (projected === null || moved || projected.hash !== desired.hash) {
+            await this.#source.write(desired.path, decodeContent(desired.content));
+        }
+        if (moved) {
+            await this.#source.delete(projected.path);
+        }
+    }
+}

package/dist/sync/AssetStateStore.d.ts

@@ -0,0 +1,28 @@
+import type * as EventStore from "@jolly-pixel/event-store";
+import type { AssetKindRegistry } from "../kinds/AssetKindRegistry.ts";
+import type { AssetKindHandler } from "../kinds/AssetKindHandler.ts";
+export interface AssetStateEntry {
+    readonly assetId: string;
+    readonly kind: string;
+    readonly handler: AssetKindHandler;
+    readonly state: unknown;
+}
+export interface AssetStateStoreOptions {
+    eventStore: EventStore.EventStore;
+    kinds: AssetKindRegistry;
+}
+/**
+ * Holds live per-asset state folded by each asset's kind handler.
+ */
+export declare class AssetStateStore {
+    #private;
+    constructor(options: AssetStateStoreOptions);
+    start(): void;
+    close(): void;
+    has(assetId: string): boolean;
+    get(assetId: string): AssetStateEntry | undefined;
+    acquire(assetId: string, kind: string): Promise<AssetStateEntry>;
+    release(assetId: string): void;
+    serialize(assetId: string, kind: string): Promise<Uint8Array>;
+}
+//# sourceMappingURL=AssetStateStore.d.ts.map

package/dist/sync/AssetStateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetStateStore.d.ts","sourceRoot":"","sources":["../../src/sync/AssetStateStore.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,UAAU,MAAM,0BAA0B,CAAC;AAG5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAMrE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC;IAClC,KAAK,EAAE,iBAAiB,CAAC;CAC1B;AAED;;GAEG;AACH,qBAAa,eAAe;;gBAQxB,OAAO,EAAE,sBAAsB;IAMjC,KAAK,IAAI,IAAI;IAOb,KAAK,IAAI,IAAI;IAMb,GAAG,CACD,OAAO,EAAE,MAAM,GACd,OAAO;IAIV,GAAG,CACD,OAAO,EAAE,MAAM,GACd,eAAe,GAAG,SAAS;IAI9B,OAAO,CACL,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,CAAC;IAuB3B,OAAO,CACL,OAAO,EAAE,MAAM,GACd,IAAI;IAID,SAAS,CACb,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,UAAU,CAAC;CAwCvB"}

package/dist/sync/AssetStateStore.js

@@ -0,0 +1,86 @@
+// Import Node.js Dependencies
+import timers from "node:timers/promises";
+import { ASSET_CHECKPOINT_EVENT_TYPES } from "../events/AssetEvents.js";
+// CONSTANTS
+const kReplayYieldEvery = 250;
+/**
+ * Holds live per-asset state folded by each asset's kind handler.
+ */
+export class AssetStateStore {
+    #eventStore;
+    #kinds;
+    #entries = new Map();
+    #replays = new Map();
+    #unsubscribe = null;
+    constructor(options) {
+        this.#eventStore = options.eventStore;
+        this.#kinds = options.kinds;
+    }
+    start() {
+        this.#unsubscribe ??= this.#eventStore.subscribe((event) => {
+            const entry = this.#entries.get(event.assetId);
+            entry?.handler.apply(entry.state, event);
+        });
+    }
+    close() {
+        this.#unsubscribe?.();
+        this.#unsubscribe = null;
+        this.#entries.clear();
+    }
+    has(assetId) {
+        return this.#entries.has(assetId);
+    }
+    get(assetId) {
+        return this.#entries.get(assetId);
+    }
+    acquire(assetId, kind) {
+        const existing = this.#entries.get(assetId);
+        if (existing !== undefined) {
+            return Promise.resolve(existing);
+        }
+        const inFlight = this.#replays.get(assetId);
+        if (inFlight !== undefined) {
+            return inFlight;
+        }
+        const replay = this.#replay(assetId, kind)
+            .then((entry) => {
+            this.#entries.set(assetId, entry);
+            return entry;
+        })
+            .finally(() => this.#replays.delete(assetId));
+        this.#replays.set(assetId, replay);
+        return replay;
+    }
+    release(assetId) {
+        this.#entries.delete(assetId);
+    }
+    async serialize(assetId, kind) {
+        const entry = this.#entries.get(assetId) ??
+            await this.#replay(assetId, kind);
+        return entry.handler.serialize(entry.state);
+    }
+    async #replay(assetId, kind) {
+        const handler = this.#kinds.get(kind);
+        const state = handler.create(assetId);
+        let events = this.#eventStore.reader.listFromCheckpoint(assetId, ASSET_CHECKPOINT_EVENT_TYPES);
+        let from = 0;
+        let sinceYield = 0;
+        while (events.length > 0) {
+            for (const event of events) {
+                handler.apply(state, event);
+                from = event.eventVersion;
+                if (++sinceYield >= kReplayYieldEvery) {
+                    sinceYield = 0;
+                    await timers.setImmediate();
+                }
+            }
+            events = this.#eventStore.reader.list(assetId, from);
+        }
+        return {
+            assetId,
+            kind,
+            handler,
+            state
+        };
+    }
+}

package/dist/sync/AssetWriter.d.ts

@@ -0,0 +1,54 @@
+import type * as EventStore from "@jolly-pixel/event-store";
+import { type Result } from "@openally/result";
+import { type AssetSource } from "@jolly-pixel/asset-source";
+import type { AssetKindRegistry } from "../kinds/AssetKindRegistry.ts";
+import { CatalogIdentitySidecar } from "../catalog/CatalogIdentitySidecar.ts";
+import { type AssetEventDataMap } from "../events/AssetEvents.ts";
+import type { AssetProjector } from "./AssetProjector.ts";
+import { type Logger } from "../logger.ts";
+export interface AssetWriterOptions {
+    eventStore: EventStore.TypedEventStore<AssetEventDataMap>;
+    kinds: AssetKindRegistry;
+    projector: AssetProjector;
+    identity: CatalogIdentitySidecar;
+    source: AssetSource;
+    logger?: Logger;
+}
+interface WriteOptions {
+    actor: EventStore.Actor;
+    /**
+     * Marks source-backed mutations as projected without another write.
+     */
+    alreadyProjected?: boolean;
+}
+export interface CreateAssetInput extends WriteOptions {
+    path: string;
+    data: Uint8Array;
+    kind?: string;
+    assetId?: string;
+}
+export interface UpdateAssetInput extends WriteOptions {
+    assetId: string;
+    data: Uint8Array;
+}
+export interface RenameAssetInput extends WriteOptions {
+    assetId: string;
+    to: string;
+}
+export interface DeleteAssetInput extends WriteOptions {
+    assetId: string;
+}
+/**
+ * Appends lifecycle events before updating projections and identity.
+ */
+export declare class AssetWriter {
+    #private;
+    constructor(options: AssetWriterOptions);
+    get identity(): CatalogIdentitySidecar;
+    create(input: CreateAssetInput): Promise<Result<EventStore.Event, Error>>;
+    update(input: UpdateAssetInput): Promise<Result<EventStore.Event, Error>>;
+    rename(input: RenameAssetInput): Promise<Result<EventStore.Event, Error>>;
+    remove(input: DeleteAssetInput): Promise<Result<EventStore.Event, Error>>;
+}
+export {};
+//# sourceMappingURL=AssetWriter.d.ts.map

package/dist/sync/AssetWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetWriter.d.ts","sourceRoot":"","sources":["../../src/sync/AssetWriter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,UAAU,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAGL,KAAK,MAAM,EACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAE9E,OAAO,EAML,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC;IAC1D,KAAK,EAAE,iBAAiB,CAAC;IACzB,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,sBAAsB,CAAC;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC;IACxB;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,WAAW;;gBASpB,OAAO,EAAE,kBAAkB;IAU7B,IAAI,QAAQ,IAAI,sBAAsB,CAErC;IAEK,MAAM,CACV,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IA8B3C,MAAM,CACJ,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAyBrC,MAAM,CACV,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAoCrC,MAAM,CACV,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CA0E5C"}

package/dist/sync/AssetWriter.js

@@ -0,0 +1,149 @@
+// Import Node.js Dependencies
+import { randomUUID } from "node:crypto";
+import { Err, Ok } from "@openally/result";
+import { AssetPathEscapeError, isStatePath, normalizeAssetPath } from "@jolly-pixel/asset-source";
+import { CatalogIdentitySidecar } from "../catalog/CatalogIdentitySidecar.js";
+import { contentHash } from "../utils/contentHash.js";
+import { ASSET_CREATED, ASSET_DELETED, ASSET_RENAMED, ASSET_UPDATED, encodeContent } from "../events/AssetEvents.js";
+import { silentLogger } from "../logger.js";
+/**
+ * Appends lifecycle events before updating projections and identity.
+ */
+export class AssetWriter {
+    #eventStore;
+    #kinds;
+    #projector;
+    #identity;
+    #source;
+    #logger;
+    constructor(options) {
+        this.#eventStore = options.eventStore;
+        this.#kinds = options.kinds;
+        this.#projector = options.projector;
+        this.#identity = options.identity;
+        this.#source = options.source;
+        this.#logger = options.logger ?? silentLogger();
+    }
+    get identity() {
+        return this.#identity;
+    }
+    async create(input) {
+        const path = writableAssetPath(input.path);
+        const kind = input.kind ?? this.#kinds.resolve(path).kind;
+        const assetId = input.assetId ?? randomUUID();
+        const assetData = {
+            path,
+            kind,
+            hash: contentHash(input.data),
+            size: input.data.byteLength,
+            content: encodeContent(input.data)
+        };
+        const appended = this.#append(assetId, kind, ASSET_CREATED, assetData, input);
+        if (!appended.ok) {
+            return appended;
+        }
+        this.#identity.set({
+            id: assetId,
+            path,
+            kind
+        });
+        await this.#saveIdentity();
+        return appended;
+    }
+    update(input) {
+        const current = this.#current(input.assetId);
+        if (!current.ok) {
+            return Promise.resolve(current);
+        }
+        const updatedAssetData = {
+            path: current.val.path,
+            kind: current.val.kind,
+            hash: contentHash(input.data),
+            size: input.data.byteLength,
+            content: encodeContent(input.data)
+        };
+        return Promise.resolve(this.#append(input.assetId, current.val.kind, ASSET_UPDATED, updatedAssetData, input));
+    }
+    async rename(input) {
+        const found = this.#current(input.assetId);
+        if (!found.ok) {
+            return found;
+        }
+        const current = found.val;
+        const to = writableAssetPath(input.to);
+        const renamedAssetData = {
+            from: current.path,
+            to,
+            kind: current.kind,
+            hash: current.hash
+        };
+        const appended = this.#append(input.assetId, current.kind, ASSET_RENAMED, renamedAssetData, input);
+        if (!appended.ok) {
+            return appended;
+        }
+        this.#identity.set({
+            id: input.assetId,
+            path: to,
+            kind: current.kind
+        });
+        await this.#saveIdentity();
+        return appended;
+    }
+    async remove(input) {
+        const found = this.#current(input.assetId);
+        if (!found.ok) {
+            return found;
+        }
+        const current = found.val;
+        const deletedAssetData = {
+            path: current.path,
+            kind: current.kind
+        };
+        const appended = this.#append(input.assetId, current.kind, ASSET_DELETED, deletedAssetData, input);
+        if (!appended.ok) {
+            return appended;
+        }
+        this.#identity.removeById(input.assetId);
+        await this.#saveIdentity();
+        return appended;
+    }
+    #current(assetId) {
+        const current = this.#projector.desired(assetId);
+        return current === null ?
+            Err(new Error(`Unknown asset "${assetId}".`)) :
+            Ok(current);
+    }
+    async #saveIdentity() {
+        try {
+            await this.#identity.save(this.#source);
+        }
+        catch (error) {
+            this.#logger
+                .withMetadata({
+                reason: error instanceof Error ? error.message : String(error)
+            })
+                .warn("identity sidecar not persisted");
+        }
+    }
+    #append(assetId, kind, eventType, eventData, options) {
+        const result = this.#eventStore.writer.append({
+            assetType: kind,
+            assetId,
+            eventType,
+            eventData,
+            actor: options.actor
+        });
+        if (result.ok &&
+            options.alreadyProjected === true) {
+            this.#projector.markProjected(assetId);
+        }
+        return result;
+    }
+}
+function writableAssetPath(input) {
+    const path = normalizeAssetPath(input);
+    if (isStatePath(path)) {
+        throw new AssetPathEscapeError(input, "reserved");
+    }
+    return path;
+}