@fabriktor/fx 0.0.152 → 0.0.153

package/dist/src/core/err.d.ts

@@ -49,5 +49,7 @@ export declare function errValidation<T extends object = Record<string, unknown>
 export declare function errResolveFailed<T extends object = Record<string, unknown>>(opts: ResolveFailedFXErrOptions<T>): FXErr;
 export declare function errUnknown(cause: unknown): FXErr;
 export declare function isFXErr(err: unknown): err is FXErr;
+export declare function errUnconfirmedMutation(): FXErr;
+export declare function isUnconfirmedMutation(err: unknown): boolean;
 export declare function fxErrMessage(err: unknown): string;
 export {};

package/dist/src/core/err.js

@@ -4,6 +4,7 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 const msgUnknownFXErr = "Unknown FX error.";
+const resourceUnconfirmedMutation = "unconfirmed_mutation";
 export const FXErrKind = {
     Required: "required",
     Validation: "validation",
@@ -78,6 +79,15 @@ export function errUnknown(cause) {
 export function isFXErr(err) {
     return err instanceof FXErr;
 }
+export function errUnconfirmedMutation() {
+    return errResolveFailed({
+        resource: resourceUnconfirmedMutation,
+        msg: "The previous mutation was not acknowledged. Repeating it could duplicate the operation.",
+    });
+}
+export function isUnconfirmedMutation(err) {
+    return isFXErr(err) && err.resource === resourceUnconfirmedMutation;
+}
 export function fxErrMessage(err) {
     if (isFXErr(err)) {
         return err.message;

package/dist/src/core/multi-create.d.ts

@@ -9,6 +9,7 @@ export declare const MultiCreateStatus: {
 };
 export type MultiCreateStatus = (typeof MultiCreateStatus)[keyof typeof MultiCreateStatus];
 export type MultiCreateCheckpoint = {
+    attempted?: boolean;
     created_id?: string;
     on_created?: (id: string) => void;
     on_rejected?: () => void;

package/dist/src/core/multi-create.js

@@ -194,6 +194,7 @@ export class MultiCreator {
                     signal,
                     idempotency_key: current.idempotency_key,
                     created_id: current.created_id,
+                    attempted: current.attempted,
                     before_request: () => {
                         signal.throwIfAborted();
                         this.opts.before_request?.();

package/dist/src/core/pull.d.ts

@@ -1,3 +1,4 @@
+import { type SearchOptions, type SearchPage } from "./search.js";
 export type PullSessionErrorHandler = (err: unknown) => void;
 export interface PullSession<TResult> {
     readonly initial: TResult;
@@ -9,13 +10,23 @@ export type PullSessionOptions<TResult> = {
     initial: TResult;
     session_token: string;
     keep_alive_interval_ms: number;
-    pull_next: (session_token: string) => Promise<TResult>;
-    keep_alive: (session_token: string) => Promise<TResult>;
+    pull_next: (session_token: string, signal: AbortSignal) => Promise<TResult>;
+    keep_alive: (session_token: string, signal: AbortSignal) => Promise<TResult>;
     resolve_session_token: (out: TResult) => string;
     closed_error: () => Error;
     pull_in_progress_error: () => Error;
     on_error?: PullSessionErrorHandler;
+    signal?: AbortSignal;
 };
+export type StartPullSessionOptions<TResult> = Omit<PullSessionOptions<TResult>, "initial" | "session_token"> & {
+    pull_initial: (signal?: AbortSignal) => Promise<TResult>;
+};
+export declare class PullSessionScope {
+    private abort;
+    signal(signal?: AbortSignal): AbortSignal;
+    reset(): void;
+}
+export declare function startPullSession<TResult>(opts: StartPullSessionOptions<TResult>): Promise<DefaultPullSession<TResult>>;
 export declare class DefaultPullSession<TResult> implements PullSession<TResult> {
     readonly initial: TResult;
     private token;
@@ -29,6 +40,9 @@ export declare class DefaultPullSession<TResult> implements PullSession<TResult>
     private closedError;
     private pullInProgressError;
     private onError?;
+    private readonly abort;
+    private readonly parentSignal?;
+    private readonly onAbort;
     constructor(opts: PullSessionOptions<TResult>);
     get sessionToken(): string;
     pullNext(): Promise<TResult>;
@@ -37,3 +51,14 @@ export declare class DefaultPullSession<TResult> implements PullSession<TResult>
     private runKeepAlive;
 }
 export declare function newPullSession<TResult>(opts: PullSessionOptions<TResult>): DefaultPullSession<TResult>;
+export declare class PullSearchSource<T, TResult, Options extends SearchOptions> {
+    private readonly options;
+    private session?;
+    private lifetime?;
+    constructor(options: {
+        start: (options: Options) => Promise<PullSession<TResult>>;
+        results: (result: TResult) => T[];
+    });
+    clear(): void;
+    search(opts: Options): Promise<SearchPage<T>>;
+}

package/dist/src/core/pull.js

@@ -3,6 +3,31 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { notifyObserver } from "./events.js";
+import { normalizeSearchPage, } from "./search.js";
+// One account/context lifetime, including requests that have not returned a session yet.
+export class PullSessionScope {
+    abort = new AbortController();
+    signal(signal) {
+        return signal
+            ? AbortSignal.any([this.abort.signal, signal])
+            : this.abort.signal;
+    }
+    reset() {
+        this.abort.abort();
+        this.abort = new AbortController();
+    }
+}
+export async function startPullSession(opts) {
+    opts.signal?.throwIfAborted();
+    const initial = await opts.pull_initial(opts.signal);
+    opts.signal?.throwIfAborted();
+    return newPullSession({
+        ...opts,
+        initial,
+        session_token: opts.resolve_session_token(initial),
+    });
+}
 export class DefaultPullSession {
     initial;
     token;
@@ -16,7 +41,11 @@ export class DefaultPullSession {
     closedError;
     pullInProgressError;
     onError;
+    abort = new AbortController();
+    parentSignal;
+    onAbort = () => this.close();
     constructor(opts) {
+        opts.signal?.throwIfAborted();
         this.initial = opts.initial;
         this.token = opts.session_token;
         this.closed = false;
@@ -27,9 +56,11 @@ export class DefaultPullSession {
         this.closedError = opts.closed_error;
         this.pullInProgressError = opts.pull_in_progress_error;
         this.onError = opts.on_error;
+        this.parentSignal = opts.signal;
         this.timer = globalThis.setInterval(() => {
             void this.keepAlive();
         }, opts.keep_alive_interval_ms);
+        this.parentSignal?.addEventListener("abort", this.onAbort, { once: true });
     }
     get sessionToken() {
         return this.token;
@@ -50,12 +81,17 @@ export class DefaultPullSession {
             if (this.closed) {
                 throw this.closedError();
             }
-            const out = await this.pullNextFn(this.token);
-            if (!this.closed) {
-                this.token = this.resolveSessionToken(out);
-            }
+            const out = await this.pullNextFn(this.token, this.abort.signal);
+            this.abort.signal.throwIfAborted();
+            this.token = this.resolveSessionToken(out);
             return out;
         }
+        catch (error) {
+            // A failed pull may already have advanced the server's seen-results set.
+            // Continuing this session could silently skip a page; refresh starts a new one.
+            this.close();
+            throw error;
+        }
         finally {
             this.pulling = false;
         }
@@ -66,6 +102,8 @@ export class DefaultPullSession {
         }
         this.closed = true;
         globalThis.clearInterval(this.timer);
+        this.parentSignal?.removeEventListener("abort", this.onAbort);
+        this.abort.abort();
     }
     async keepAlive() {
         if (this.closed || this.pulling || this.keepAliveTask !== undefined) {
@@ -84,14 +122,19 @@ export class DefaultPullSession {
     }
     async runKeepAlive() {
         try {
-            const out = await this.keepAliveFn(this.token);
+            const out = await this.keepAliveFn(this.token, this.abort.signal);
             if (!this.closed) {
                 this.token = this.resolveSessionToken(out);
             }
         }
         catch (err) {
             if (!this.closed) {
-                this.onError?.(err);
+                this.close();
+                notifyObserver(() => {
+                    if (this.onError)
+                        return this.onError(err);
+                    throw err;
+                });
             }
         }
     }
@@ -99,3 +142,62 @@ export class DefaultPullSession {
 export function newPullSession(opts) {
     return new DefaultPullSession(opts);
 }
+// Adapts sequential pull sessions to the existing paged SearchController.
+// Its clear method belongs to the controller's on_clear hook.
+export class PullSearchSource {
+    options;
+    session;
+    lifetime;
+    constructor(options) {
+        this.options = options;
+    }
+    clear() {
+        this.lifetime?.abort();
+        this.lifetime = undefined;
+        this.session?.close();
+        this.session = undefined;
+    }
+    async search(opts) {
+        const page = normalizeSearchPage(opts.page);
+        if (page === normalizeSearchPage())
+            this.clear();
+        const lifetime = this.lifetime ?? new AbortController();
+        this.lifetime = lifetime;
+        const cancel = () => lifetime.abort();
+        opts.signal?.throwIfAborted();
+        opts.signal?.addEventListener("abort", cancel, { once: true });
+        try {
+            let out;
+            if (!this.session) {
+                const session = await this.options.start({
+                    ...opts,
+                    signal: lifetime.signal,
+                });
+                if (lifetime.signal.aborted || this.lifetime !== lifetime) {
+                    session.close();
+                    lifetime.signal.throwIfAborted();
+                    throw new Error("Pull selection was replaced.");
+                }
+                this.session = session;
+                out = session.initial;
+            }
+            else {
+                out = await this.session.pullNext();
+            }
+            lifetime.signal.throwIfAborted();
+            const results = this.options.results(out);
+            const has_more = results.length > 0;
+            return {
+                results,
+                page,
+                per_page: results.length,
+                has_more,
+                next_page: has_more ? page + 1 : page,
+                done: !has_more,
+            };
+        }
+        finally {
+            opts.signal?.removeEventListener("abort", cancel);
+        }
+    }
+}

package/dist/src/core/search-controller.d.ts

@@ -12,6 +12,7 @@ export type SearchControllerOptions<T, Options extends SearchOptions> = {
     search: (opts: Options) => Promise<SearchPage<T>>;
     on_change: (state: SearchState<T>) => void;
     on_error?: (error: unknown) => void;
+    on_clear?: () => void;
 };
 export declare class SearchController<T extends SearchResultWithID, Options extends SearchOptions> {
     private readonly options;

package/dist/src/core/search-controller.js

@@ -24,6 +24,7 @@ export class SearchController {
     clear() {
         this.request?.abort();
         this.request = undefined;
+        this.options.on_clear?.();
         this.selection = undefined;
         this.next_page = normalizeSearchPage();
         this.publish(this.emptyState());

package/dist/src/feed/feed.d.ts

@@ -1,8 +1,33 @@
 import { type FeedFavorite, type FeedObject, type FeedPost, type FeedReaction, type OperationResult, type RPFeedPull } from "@fabriktor/schema";
-import type { FeedOperator, OperationResultOf, StorageUploadFile } from "@fabriktor/client";
+import { type FeedOperator, type OperationResultOf, type StorageUploadFile } from "@fabriktor/client";
 import { type PullSession, type PullSessionErrorHandler } from "../core/pull.js";
-import { type SearchOptions, type SearchPage } from "../core/search.js";
+import { type OwnerSearchOptions, type SearchPage } from "../core/search.js";
 import { type StorageFXOperator, type StoragePersonalBoxUploadResult } from "../storage/storage.js";
+import { EventBus } from "../core/events.js";
+import type { MultiCreateCheckpoint } from "../core/multi-create.js";
+export * from "./validation.js";
+export * from "./media.js";
+import { type SaveFeedPostOptions, type FeedPostSaveResult, type FeedPostSaveState } from "./media.js";
+export declare const FeedEvents: {
+    Changed: import("../index.js").EventKey<{
+        post_id: string;
+    }>;
+};
+export type FeedReadOptions = {
+    id: string;
+    signal?: AbortSignal;
+};
+export type SavedFeedPost = FeedFavorite & {
+    post: FeedPost | null;
+};
+export type FeedFavoriteListOptions = {
+    owner_id: string;
+    signal?: AbortSignal;
+};
+export type DeleteFeedPostOptions = {
+    record: FeedPost;
+    owner_id: string;
+};
 type FeedPullOptions = Parameters<FeedOperator["pull"]>[0];
 type FeedPostInsertOptions = Parameters<FeedOperator["insertOneFeedPost"]>[0];
 type FeedPostReplaceOptions = Parameters<FeedOperator["replaceOneFeedPost"]>[0];
@@ -30,13 +55,15 @@ export declare const FeedMediaPostStatus: {
 };
 export type FeedMediaPostStatus = (typeof FeedMediaPostStatus)[keyof typeof FeedMediaPostStatus];
 export type FeedReactionType = FeedReactionInsert["reaction_type"];
-export type CreateFeedPostOptions = FeedPostInsertOptions;
-export type ReplaceFeedPostOptions = FeedPostReplaceOptions;
+export type CreateFeedPostOptions = FeedPostInsertOptions & MultiCreateCheckpoint;
+export type ReplaceFeedPostOptions = FeedPostReplaceOptions & {
+    expected?: Pick<FeedPost, "owner_id" | "updated_at">;
+};
 export type CreateFeedReactionOptions = FeedReactionInsertOptions;
 export type ReplaceFeedReactionOptions = FeedReactionReplaceOptions;
 export type CreateFeedFavoriteOptions = FeedFavoriteInsertOptions;
 export type ReplaceFeedFavoriteOptions = FeedFavoriteReplaceOptions;
-export type SearchFeedPostsOptions = SearchOptions;
+export type SearchFeedPostsOptions = OwnerSearchOptions;
 export type SearchFeedPostsPage = SearchPage<FeedPost>;
 export type FeedPullContext = Pick<FeedPullOptions, "contact_ids" | "pull_type" | "entity_id" | "research">;
 export type FeedTextPostContent = Pick<FeedPostInsert, "text">;
@@ -45,11 +72,13 @@ export type FeedPullResult = OperationResultOf<RPFeedPull>;
 export type FeedSession = PullSession<FeedPullResult>;
 export type FeedSessionErrorHandler = PullSessionErrorHandler;
 export type FeedFXOptions = {
+    events?: EventBus;
     feed: FeedOperator;
     storage_fx: StorageFXOperator;
     keep_alive_interval_ms: number;
 };
 export type StartFeedSessionOptions = FeedPullContext & {
+    signal?: AbortSignal;
     on_error?: FeedSessionErrorHandler;
 };
 export type AddFeedReactionOptions = {
@@ -79,7 +108,10 @@ export type CreateFeedReferenceOptions = {
 export type RemoveFeedReferenceOptions = {
     post: FeedPost;
 };
-export type FeedMediaUploadOptions = {
+export type FeedMediaUploadOptions = MultiCreateCheckpoint & {
+    state?: FeedPostSaveState;
+    signal?: AbortSignal;
+    idempotency_key?: string;
     user_id?: string;
     uploader_id?: string;
     full_quality?: boolean;
@@ -132,6 +164,19 @@ export type CreateFeedPostWithMediaResult = {
     error: unknown;
 };
 export interface FeedFXOperator {
+    saveFeedPost(opts: SaveFeedPostOptions): Promise<FeedPostSaveResult>;
+    readOwnReaction(opts: FeedReadOptions): Promise<FeedReaction | null>;
+    readFeedPost(opts: FeedReadOptions): Promise<FeedPost | null>;
+    listSavedFeedPosts(opts: FeedFavoriteListOptions): Promise<SavedFeedPost[]>;
+    removeSavedFeedPost(opts: {
+        id: string;
+        owner_id: string;
+    }): Promise<void>;
+    deleteFeedPost(opts: DeleteFeedPostOptions): Promise<void>;
+    restrictFeed(opts: {
+        new_visibility: number;
+    }): Promise<void>;
+    reset(): void;
     createFeedPost(opts: CreateFeedPostOptions): Promise<FeedPost>;
     replaceFeedPost(opts: ReplaceFeedPostOptions): Promise<FeedPost>;
     searchFeedPosts(opts: SearchFeedPostsOptions): Promise<SearchFeedPostsPage>;
@@ -153,6 +198,9 @@ export interface FeedFXOperator {
     createReferenceWithMedia(opts: CreateFeedReferenceWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
 }
 export declare class FeedFX implements FeedFXOperator {
+    private readonly sessions;
+    private readonly events;
+    private mutating;
     private feed;
     private storage_fx;
     private keep_alive_interval_ms;
@@ -161,9 +209,25 @@ export declare class FeedFX implements FeedFXOperator {
     private removed_actions;
     private action_ids;
     constructor(opts: FeedFXOptions);
+    reset(): void;
     createFeedPost(opts: CreateFeedPostOptions): Promise<FeedPost>;
     replaceFeedPost(opts: ReplaceFeedPostOptions): Promise<FeedPost>;
     searchFeedPosts(opts: SearchFeedPostsOptions): Promise<SearchFeedPostsPage>;
+    readOwnReaction(opts: FeedReadOptions): Promise<FeedReaction | null>;
+    readFeedPost(opts: FeedReadOptions): Promise<FeedPost | null>;
+    listSavedFeedPosts(opts: FeedFavoriteListOptions): Promise<SavedFeedPost[]>;
+    removeSavedFeedPost(opts: {
+        id: string;
+        owner_id: string;
+    }): Promise<void>;
+    deleteFeedPost(opts: DeleteFeedPostOptions): Promise<void>;
+    restrictFeed(opts: {
+        new_visibility: number;
+    }): Promise<void>;
+    private checkVersion;
+    private requireFeedPost;
+    private changed;
+    private mutate;
     createFeedReaction(opts: CreateFeedReactionOptions): Promise<FeedReaction>;
     replaceFeedReaction(opts: ReplaceFeedReactionOptions): Promise<FeedReaction>;
     createFeedFavorite(opts: CreateFeedFavoriteOptions): Promise<FeedFavorite>;
@@ -177,6 +241,7 @@ export declare class FeedFX implements FeedFXOperator {
     removeReply(opts: RemoveFeedReplyOptions): Promise<OperationResult>;
     createReference(opts: CreateFeedReferenceOptions): Promise<OperationResult>;
     removeReference(opts: RemoveFeedReferenceOptions): Promise<OperationResult>;
+    saveFeedPost(opts: SaveFeedPostOptions): Promise<FeedPostSaveResult>;
     createPostWithMedia(opts: CreateFeedPostWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
     createReplyWithMedia(opts: CreateFeedReplyWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
     createReferenceWithMedia(opts: CreateFeedReferenceWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
@@ -196,4 +261,3 @@ export declare class FeedFX implements FeedFXOperator {
     private setActionRunning;
 }
 export declare function newFeedFX(opts: FeedFXOptions): FeedFX;
-export {};