@fabriktor/fx 0.0.151 → 0.0.153

package/dist/src/marketplace/marketplace.js

@@ -3,11 +3,18 @@
 // 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 { PullTypeBatch, PullTypeKeepAlive, PullTypeResearch, } from "@fabriktor/schema";
-import { errRequired, errResolveFailed, errValidation } from "../core/err.js";
-import { requiredOperationID } from "../core/id.js";
-import { newPullSession, } from "../core/pull.js";
+import { isClientErr, queryParams, } from "@fabriktor/client";
+import { PullTypeBatch, PullTypeKeepAlive, PullTypeResearch, PullTypeSingle, OwnerIDKey, } from "@fabriktor/schema";
+import { errRequired, errResolveFailed, errValidation, errUnconfirmedMutation, } from "../core/err.js";
+import { requiredOperationID, resolvedID } from "../core/id.js";
+import { startPullSession, PullSessionScope, } from "../core/pull.js";
 import { runOwnerSearch, } from "../core/search.js";
+import { createEvent, EventBus, notifyObserver } from "../core/events.js";
+import { marketplacePostInput, prepareMarketplacePost, validateMarketplaceUserType, } from "./validation.js";
+export * from "./validation.js";
+export const MarketplaceEvents = {
+    Changed: createEvent(),
+};
 const newMarketplaceSessionToken = "";
 const resourceMarketplaceSessionToken = "marketplace_session_token";
 const resourceMarketplacePost = "marketplace_post";
@@ -25,25 +32,118 @@ const msgMarketplaceEntityIDRequired = "Entity ID is required for a batch market
 const msgMarketplaceResearchRequired = "Research is required for a research marketplace session.";
 const msgMarketplaceCountryRequired = "Country is required for marketplace welcome research.";
 export class MarketplaceFX {
+    sessions = new PullSessionScope();
+    events;
+    mutating = false;
     marketplace;
     keep_alive_interval_ms;
     constructor(opts) {
         validateMarketplaceFXOptions(opts);
         this.marketplace = opts.marketplace;
+        this.events = opts.events ?? new EventBus();
         this.keep_alive_interval_ms = opts.keep_alive_interval_ms;
     }
+    reset() {
+        this.sessions.reset();
+    }
     async createMarketplacePost(opts) {
-        const out = await this.marketplace.insertOneMarketplacePost(opts);
-        const id = requiredOperationID(out, msgCreatedMarketplacePostIDMissing);
-        return await this.findMarketplacePost(id);
+        return await this.mutate(async (signal) => {
+            let id = resolvedID(opts.created_id);
+            if (!id) {
+                if (opts.attempted)
+                    throw errUnconfirmedMutation();
+                const input = prepareMarketplacePost(opts.in);
+                opts.before_request?.();
+                let out;
+                try {
+                    out = await this.marketplace.insertOneMarketplacePost({
+                        in: input,
+                        idempotency_key: opts.idempotency_key,
+                        signal,
+                    });
+                }
+                catch (error) {
+                    // Validation and moderation reject before insertion. Other failures may
+                    // have committed; keep the original request immutable for an explicit retry.
+                    if (isClientErr(error) &&
+                        (error.status === 400 || error.status === 422))
+                        notifyObserver(() => opts.on_rejected?.());
+                    throw error;
+                }
+                id = requiredOperationID(out, msgCreatedMarketplacePostIDMissing);
+                notifyObserver(() => opts.on_created?.(id));
+            }
+            signal.throwIfAborted();
+            const post = await this.findMarketplacePost(id, signal);
+            signal.throwIfAborted();
+            this.changed(post.owner_id, "posts", id);
+            return post;
+        }, opts.signal);
     }
     async replaceMarketplacePost(opts) {
-        await this.marketplace.replaceOneMarketplacePost(opts);
-        return await this.findMarketplacePost(opts.id);
+        return await this.mutate(async (signal) => {
+            if (opts.created_id) {
+                if (opts.created_id !== opts.id)
+                    throw errValidation({
+                        field: "id",
+                        msg: "The saved listing does not match this edit.",
+                    });
+                const post = await this.findMarketplacePost(opts.id, signal);
+                if (opts.expected && post.owner_id !== opts.expected.owner_id)
+                    throw errValidation({
+                        field: "owner_id",
+                        msg: "This listing belongs to another owner.",
+                    });
+                signal.throwIfAborted();
+                this.changed(post.owner_id, "posts", post.id);
+                return post;
+            }
+            if (opts.attempted)
+                throw errUnconfirmedMutation();
+            const current = await this.findMarketplacePost(opts.id, signal);
+            signal.throwIfAborted();
+            if (opts.expected &&
+                (current.owner_id !== opts.expected.owner_id ||
+                    current.updated_at !== opts.expected.updated_at)) {
+                throw errValidation({
+                    field: "updated_at",
+                    msg: "Reload the listing before saving it.",
+                });
+            }
+            const input = prepareMarketplacePost({
+                ...marketplacePostInput(current),
+                ...opts.in,
+            });
+            opts.before_request?.();
+            try {
+                await this.marketplace.replaceOneMarketplacePost({
+                    id: opts.id,
+                    in: input,
+                    signal,
+                    idempotency_key: opts.idempotency_key,
+                });
+            }
+            catch (error) {
+                if (isClientErr(error) &&
+                    (error.status === 400 || error.status === 422))
+                    notifyObserver(() => opts.on_rejected?.());
+                throw error;
+            }
+            notifyObserver(() => opts.on_created?.(opts.id));
+            signal.throwIfAborted();
+            this.changed(current.owner_id, "posts", current.id);
+            const post = await this.findMarketplacePost(opts.id, signal);
+            signal.throwIfAborted();
+            return post;
+        }, opts.signal);
     }
     async searchMarketplacePosts(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({
+                post_type: opts.post_type,
+                user_type: opts.user_type,
+            }),
             search: (searchOpts) => this.marketplace.searchManyMarketplacePosts(searchOpts),
         });
     }
@@ -57,28 +157,30 @@ export class MarketplaceFX {
         return await this.findMarketplaceFavorite(opts.id);
     }
     async startSession(opts) {
-        const { on_error, ...input } = opts;
+        const { on_error, signal: parentSignal, ...input } = opts;
+        const signal = this.sessions.signal(parentSignal);
         const context = marketplaceSessionContext(input);
-        const initial = await this.marketplace.pull({
-            ...context,
-            session_token: newMarketplaceSessionToken,
-            is_new_session: true,
-        });
-        const session_token = marketplaceSessionToken(initial);
-        return newPullSession({
-            initial,
-            session_token,
+        return await startPullSession({
+            signal,
+            pull_initial: (signal) => this.marketplace.pull({
+                ...context,
+                session_token: newMarketplaceSessionToken,
+                is_new_session: true,
+                signal,
+            }),
             keep_alive_interval_ms: this.keep_alive_interval_ms,
-            pull_next: async (token) => {
+            pull_next: async (token, signal) => {
                 return await this.marketplace.pull({
                     ...context,
                     session_token: token,
+                    signal,
                     is_new_session: false,
                 });
             },
-            keep_alive: async (token) => {
+            keep_alive: async (token, signal) => {
                 return await this.marketplace.pull({
                     session_token: token,
+                    signal,
                     is_new_session: false,
                     pull_type: PullTypeKeepAlive,
                     entity_id: "",
@@ -104,12 +206,163 @@ export class MarketplaceFX {
             research,
             research_user_type: opts.research_user_type,
             on_error: opts.on_error,
+            signal: opts.signal,
         });
     }
-    async findMarketplacePost(id) {
-        const out = await this.marketplace.findOneMarketplacePost({
-            id,
+    // Shared discoveries are read through pull; generic find-by-ID is owner-only.
+    async readMarketplacePost(opts) {
+        const signal = this.sessions.signal(opts.signal);
+        signal.throwIfAborted();
+        const id = this.requireID(opts.id);
+        try {
+            const out = await this.marketplace.pull({
+                session_token: newMarketplaceSessionToken,
+                is_new_session: true,
+                pull_type: PullTypeSingle,
+                entity_id: id,
+                research: "",
+                research_user_type: "",
+                signal,
+            });
+            signal.throwIfAborted();
+            return out.value?.v.find((post) => post.id === id) ?? null;
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            if (isClientErr(error) && (error.status === 403 || error.status === 404))
+                return null;
+            throw error;
+        }
+    }
+    async listMarketplaceFavorites(opts) {
+        const signal = this.sessions.signal(opts.signal);
+        signal.throwIfAborted();
+        const out = await this.marketplace.queryMarketplaceFavorites({
+            query: queryParams({
+                [OwnerIDKey]: this.requireID(opts.owner_id),
+                post_id: opts.post_id === undefined ? undefined : this.requireID(opts.post_id),
+            }),
+            signal,
+        });
+        signal.throwIfAborted();
+        return out.value ?? [];
+    }
+    // Favorites have an unpaged query route. Preserve its order and resolve each
+    // public listing through pull, including unavailable entries for removal.
+    async listSavedMarketplacePosts(opts) {
+        const signal = this.sessions.signal(opts.signal);
+        const favorites = await this.listMarketplaceFavorites({ ...opts, signal });
+        const results = [];
+        for (const favorite of favorites) {
+            signal.throwIfAborted();
+            const post = await this.readMarketplacePost({
+                id: favorite.post_id,
+                signal,
+            });
+            signal.throwIfAborted();
+            results.push({ ...favorite, post });
+        }
+        return results;
+    }
+    // Recheck persisted favorites before creating or removing; clean old duplicates serially.
+    async setMarketplaceFavorite(opts) {
+        return await this.mutate(async (signal) => {
+            const existing = await this.listMarketplaceFavorites({ ...opts, signal });
+            if (opts.saved) {
+                if (existing.length)
+                    return existing[0];
+                if (!(await this.readMarketplacePost({ id: opts.post_id, signal }))) {
+                    throw errResolveFailed({
+                        resource: resourceMarketplacePost,
+                        msg: msgMarketplacePostMissing,
+                    });
+                }
+                const out = await this.marketplace.insertOneMarketplaceFavorite({
+                    in: { post_id: opts.post_id },
+                    signal,
+                });
+                signal.throwIfAborted();
+                const id = requiredOperationID(out, msgCreatedMarketplaceFavoriteIDMissing);
+                const found = await this.marketplace.findOneMarketplaceFavorite({
+                    id,
+                    signal,
+                });
+                signal.throwIfAborted();
+                if (!found.value)
+                    throw errResolveFailed({
+                        resource: resourceMarketplaceFavorite,
+                        msg: msgMarketplaceFavoriteMissing,
+                    });
+                this.changed(opts.owner_id, "favorites", opts.post_id);
+                return found.value;
+            }
+            for (const favorite of existing) {
+                signal.throwIfAborted();
+                await this.marketplace.deleteOneMarketplaceFavorite({
+                    id: favorite.id,
+                    signal,
+                });
+            }
+            signal.throwIfAborted();
+            this.changed(opts.owner_id, "favorites", opts.post_id);
+            return null;
+        }, opts.signal);
+    }
+    async deleteMarketplacePost(opts) {
+        return await this.mutate(async (signal) => {
+            const owner = this.requireID(opts.owner_id);
+            const current = await this.findMarketplacePost(opts.record.id, signal);
+            signal.throwIfAborted();
+            if (current.owner_id !== owner ||
+                current.updated_at !== opts.record.updated_at) {
+                throw errValidation({
+                    field: "updated_at",
+                    msg: "Reload the listing before deleting it.",
+                });
+            }
+            await this.marketplace.deleteOneMarketplacePost({
+                id: current.id,
+                signal,
+            });
+            signal.throwIfAborted();
+            this.changed(owner, "posts", current.id);
         });
+    }
+    async mutate(fn, parent) {
+        if (this.mutating)
+            throw errValidation({
+                msg: "A Marketplace action is already in progress.",
+            });
+        const signal = this.sessions.signal(parent);
+        signal.throwIfAborted();
+        this.mutating = true;
+        try {
+            const result = await fn(signal);
+            signal.throwIfAborted();
+            return result;
+        }
+        finally {
+            this.mutating = false;
+        }
+    }
+    requireID(value) {
+        const id = resolvedID(value);
+        if (!id)
+            throw errRequired({
+                field: "id",
+                msg: "A Marketplace record or owner ID is required.",
+            });
+        return id;
+    }
+    changed(owner_id, resource, post_id) {
+        this.events.publish(MarketplaceEvents.Changed, {
+            owner_id,
+            resource,
+            post_id,
+        });
+    }
+    async findMarketplacePost(id, signal) {
+        const out = await this.marketplace.findOneMarketplacePost({ id, signal });
         const post = out.value;
         if (post === undefined) {
             throw errResolveFailed({
@@ -170,6 +423,7 @@ function marketplaceSessionContext(opts) {
                     msg: msgMarketplaceResearchRequired,
                 });
             }
+            validateMarketplaceUserType(opts.research_user_type);
             return {
                 pull_type: PullTypeResearch,
                 entity_id: "",

package/dist/src/marketplace/validation.d.ts

@@ -0,0 +1,11 @@
+import { PostTypeEmployment, PostTypeJob, type InMarketplacePost, type MarketplacePost } from "@fabriktor/schema";
+export type MarketplacePostType = typeof PostTypeEmployment | typeof PostTypeJob;
+export declare const marketplaceUserTypes: readonly ["client", "employee", "employer"];
+export declare const MarketplaceResource: {
+    readonly Posts: "marketplace_posts";
+    readonly Favorites: "marketplace_favorites";
+};
+export declare function marketplacePostTypes(user_type: string): readonly MarketplacePostType[];
+export declare function validateMarketplaceUserType(user_type: string): void;
+export declare function marketplacePostInput(post: MarketplacePost): InMarketplacePost;
+export declare function prepareMarketplacePost(input: InMarketplacePost): InMarketplacePost;

package/dist/src/marketplace/validation.js

@@ -0,0 +1,76 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// 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 { ColMarketplaceMarketplacePosts, ColMarketplaceMarketplaceFavorites, PostTypeEmployment, PostTypeJob, UserTypeClient, UserTypeEmployee, UserTypeEmployer, } from "@fabriktor/schema";
+import { errRequired, errValidation } from "../core/err.js";
+export const marketplaceUserTypes = [
+    UserTypeClient,
+    UserTypeEmployee,
+    UserTypeEmployer,
+];
+export const MarketplaceResource = {
+    Posts: ColMarketplaceMarketplacePosts,
+    Favorites: ColMarketplaceMarketplaceFavorites,
+};
+export function marketplacePostTypes(user_type) {
+    switch (user_type) {
+        case UserTypeEmployer:
+            return [PostTypeEmployment, PostTypeJob];
+        case UserTypeEmployee:
+            return [PostTypeEmployment];
+        case UserTypeClient:
+            return [PostTypeJob];
+        default:
+            return [];
+    }
+}
+export function validateMarketplaceUserType(user_type) {
+    if (!marketplaceUserTypes.some((value) => value === user_type)) {
+        throw errValidation({
+            field: "user_type",
+            msg: "A Marketplace account role is required.",
+        });
+    }
+}
+export function marketplacePostInput(post) {
+    return {
+        text: { text: post.text.text, file: "", file_url: "", mime: "" },
+        post_type: post.post_type,
+        user_type: post.user_type,
+        country: post.country,
+        state: post.state,
+        city: post.city,
+    };
+}
+// Project only editable fields. Embeddings, ownership and normalization stay server-owned.
+export function prepareMarketplacePost(input) {
+    validateMarketplaceUserType(input.user_type);
+    if (!marketplacePostTypes(input.user_type).some((value) => value === input.post_type)) {
+        throw errValidation({
+            field: "post_type",
+            msg: "This listing purpose is unavailable for the selected role.",
+        });
+    }
+    const text = input.text.text.trim();
+    if (!text)
+        throw errRequired({
+            field: "text",
+            msg: "A listing description is required.",
+        });
+    const country = input.country.trim().toUpperCase();
+    if (!country)
+        throw errRequired({
+            field: "country",
+            msg: "A listing country is required.",
+        });
+    return {
+        text: { text, file: "", file_url: "", mime: "" },
+        post_type: input.post_type,
+        user_type: input.user_type,
+        country,
+        state: input.state.trim(),
+        city: input.city.trim(),
+    };
+}

package/dist/src/routes/departure.d.ts

@@ -29,6 +29,10 @@ export declare const RoutePlanningBlock: {
     readonly DepartureChanged: "route_departure_changed";
     readonly DestinationTimezone: "route_destination_timezone";
     readonly DestinationChanged: "route_destination_changed";
+    readonly DestinationOwner: "route_destination_owner";
+    readonly DestinationArchived: "route_destination_archived";
+    readonly DestinationAddress: "route_destination_address";
+    readonly DestinationClient: "route_destination_client";
 };
 export declare function companyRouteDeparture(user: User): RouteDeparture;
 export declare function warehouseRouteDeparture(warehouse: Warehouse, owner_id: string): RouteDeparture;

package/dist/src/routes/departure.js

@@ -12,6 +12,10 @@ export const RoutePlanningBlock = {
     DepartureChanged: "route_departure_changed",
     DestinationTimezone: "route_destination_timezone",
     DestinationChanged: "route_destination_changed",
+    DestinationOwner: "route_destination_owner",
+    DestinationArchived: "route_destination_archived",
+    DestinationAddress: "route_destination_address",
+    DestinationClient: "route_destination_client",
 };
 export function companyRouteDeparture(user) {
     if (user.account_identity !== UserTypeEmployer ||
@@ -57,11 +61,14 @@ export async function loadRouteDeparture(readers, owner_id, reference, signal) {
     throw new PreActionBlocked(RoutePlanningBlock.Departure);
 }
 export function validateRoutePlanLocation(location, owner_id, timezone) {
-    if (location.owner_id !== owner_id ||
-        location.is_archived ||
-        !location.place_id.trim() ||
-        !resolvedID(location.client_id))
-        throw new PreActionBlocked(RoutePlanningBlock.DestinationChanged);
+    if (location.owner_id !== owner_id)
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationOwner);
+    if (location.is_archived)
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationArchived);
+    if (!location.place_id?.trim())
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationAddress);
+    if (!resolvedID(location.client_id))
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationClient);
     if (addressTimezone(location) !== timezone)
         throw new PreActionBlocked(RoutePlanningBlock.DestinationTimezone);
 }

package/dist/src/storage/storage.d.ts

@@ -1,5 +1,7 @@
 import { type Object as StorageObject, type RPStorageUpload } from "@fabriktor/schema";
 import type { OperationResultOf, RequestOptions, OptionalField, StorageCollection, StorageOperator, StorageUploadFile, UploadStorageOptions } from "@fabriktor/client";
+export declare const storageMaxFiles = 20;
+export declare const storageMaxBytes: number;
 type StorageDownloadOptions = Parameters<StorageOperator["download"]>[1];
 export declare const StorageUploadModeration: {
     readonly Clean: "clean";
@@ -20,6 +22,8 @@ export type UploadObjectsOptions = UploadStorageOptions & {
     col: StorageCollection;
 };
 export type UploadObjectsWithPersonalBoxOptions = UploadObjectsOptions & {
+    primary?: StorageUploadResult;
+    on_primary?: (result: StorageUploadResult) => void;
     personal_box_idempotency_key?: string;
     user_id?: string;
     save_to_personal_box?: boolean;
@@ -27,6 +31,13 @@ export type UploadObjectsWithPersonalBoxOptions = UploadObjectsOptions & {
 export type DownloadObjectsOptions = OptionalField<StorageDownloadOptions, "mime_prefix"> & {
     col: StorageCollection;
 };
+export type DeleteOwnedStorageObjectOptions = {
+    col: StorageCollection;
+    id: string;
+    owner_id: string;
+    uploader_id: string;
+    signal?: AbortSignal;
+};
 export type UploadUserObjectsOptions = RequestOptions & {
     user_id: string;
     uploader_id?: string;
@@ -62,6 +73,7 @@ export type StoragePersonalBoxUploadResult = {
 };
 export type UploadChatObjectsResult = StoragePersonalBoxUploadResult;
 export interface StorageFXOperator {
+    deleteOwnedObject(opts: DeleteOwnedStorageObjectOptions): Promise<void>;
     uploadObjects(opts: UploadObjectsOptions): Promise<StorageUploadResult>;
     uploadObjectsWithPersonalBox(opts: UploadObjectsWithPersonalBoxOptions): Promise<StoragePersonalBoxUploadResult>;
     downloadObjects(opts: DownloadObjectsOptions): Promise<OperationResultOf<StorageObject[]>>;
@@ -74,8 +86,10 @@ export declare class StorageFX implements StorageFXOperator {
     uploadObjects(opts: UploadObjectsOptions): Promise<StorageUploadResult>;
     uploadObjectsWithPersonalBox(opts: UploadObjectsWithPersonalBoxOptions): Promise<StoragePersonalBoxUploadResult>;
     downloadObjects(opts: DownloadObjectsOptions): Promise<OperationResultOf<StorageObject[]>>;
+    deleteOwnedObject(opts: DeleteOwnedStorageObjectOptions): Promise<void>;
     uploadUserObjects(opts: UploadUserObjectsOptions): Promise<StorageUploadResult>;
     uploadChatObjects(opts: UploadChatObjectsOptions): Promise<UploadChatObjectsResult>;
 }
 export declare function newStorageFX(opts: StorageFXOptions): StorageFX;
+export declare function validateStorageUploadFiles(files: StorageUploadFile[]): void;
 export {};

package/dist/src/storage/storage.js

@@ -4,9 +4,11 @@
 // 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 { ColStorageChat, ColStorageUsers, } from "@fabriktor/schema";
+import { isClientErr } from "@fabriktor/client";
 import { errRequired, errValidation } from "../core/err.js";
-const maxUploadFiles = 20;
-const maxUploadBytes = 1024 * 1024 * 1024;
+import { notifyObserver } from "../core/events.js";
+export const storageMaxFiles = 20;
+export const storageMaxBytes = 1024 * 1024 * 1024;
 const mimePrefixAll = "";
 const extensionHEIC = ".heic";
 const extensionHEIF = ".heif";
@@ -53,17 +55,20 @@ export class StorageFX {
     }
     async uploadObjectsWithPersonalBox(opts) {
         const personal_box_user_id = personalBoxUserID(opts);
-        const primary = await this.uploadObjects({
-            col: opts.col,
-            owner_id: opts.owner_id,
-            uploader_id: opts.uploader_id,
-            full_quality: opts.full_quality,
-            public_url: opts.public_url,
-            files: opts.files,
-            signal: opts.signal,
-            idempotency_key: opts.idempotency_key,
-        });
-        if (personal_box_user_id === undefined) {
+        opts.signal?.throwIfAborted();
+        const primary = opts.primary ??
+            (await this.uploadObjects({
+                col: opts.col,
+                owner_id: opts.owner_id,
+                uploader_id: opts.uploader_id,
+                full_quality: opts.full_quality,
+                public_url: opts.public_url,
+                files: opts.files,
+                signal: opts.signal,
+                idempotency_key: opts.idempotency_key,
+            }));
+        notifyObserver(() => opts.on_primary?.(primary));
+        if (personal_box_user_id === undefined || primary.all_forbidden) {
             return {
                 status: StoragePersonalBoxUploadStatus.PrimaryOnly,
                 primary,
@@ -108,6 +113,32 @@ export class StorageFX {
             mime_prefix: mime_prefix?.trim() ?? mimePrefixAll,
         });
     }
+    async deleteOwnedObject(opts) {
+        opts.signal?.throwIfAborted();
+        const stored = await this.downloadObjects(opts);
+        opts.signal?.throwIfAborted();
+        const object = stored.value?.find((value) => value.id === opts.id);
+        if (!object)
+            return;
+        if (!opts.uploader_id.trim() ||
+            object.owner_id !== opts.owner_id ||
+            object.uploader_id !== opts.uploader_id)
+            throw errValidation({
+                field: "owner_id",
+                msg: "Storage object does not belong to this owner and uploader.",
+            });
+        try {
+            await this.storage.deleteOne(opts.col, {
+                id: object.id,
+                signal: opts.signal,
+            });
+        }
+        catch (error) {
+            if (!isClientErr(error) || error.status !== 404)
+                throw error;
+        }
+        opts.signal?.throwIfAborted();
+    }
     async uploadUserObjects(opts) {
         const user_id = opts.user_id.trim();
         if (user_id === "") {
@@ -171,25 +202,28 @@ function validateUpload(opts) {
             msg: msgOwnerIDRequired,
         });
     }
-    if (opts.files.length === 0) {
+    validateStorageUploadFiles(opts.files);
+}
+export function validateStorageUploadFiles(files) {
+    if (files.length === 0) {
         throw errRequired({
             field: "files",
             msg: msgUploadFilesRequired,
         });
     }
-    if (opts.files.length > maxUploadFiles) {
+    if (files.length > storageMaxFiles) {
         throw errValidation({
             field: "files",
             msg: msgUploadTooManyFiles,
         });
     }
-    if (uploadSize(opts.files) > maxUploadBytes) {
+    if (uploadSize(files) > storageMaxBytes) {
         throw errValidation({
             field: "files",
             msg: msgUploadTooLarge,
         });
     }
-    if (opts.files.some(isHEIC)) {
+    if (files.some(isHEIC)) {
         throw errValidation({
             field: "files",
             msg: msgHEICUnsupported,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.151",
+  "version": "0.0.153",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,9 +17,9 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "0.0.99",
+    "@fabriktor/client": "0.0.100",
     "@fabriktor/fx": "0.0.94",
-    "@fabriktor/schema": "0.0.69",
+    "@fabriktor/schema": "0.0.70",
     "convert": "8.0.2"
   }
 }