@fabriktor/fx 0.0.30 → 0.0.32

package/dist/src/session/session.js

@@ -3,12 +3,20 @@
 // 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
+export const SignInMode = {
+    Email: "email",
+    Username: "username",
+};
 export class SessionFX {
     auth;
+    connections;
     users;
+    users_fx;
     constructor(opts) {
         this.auth = opts.auth;
+        this.connections = opts.connections;
         this.users = opts.users;
+        this.users_fx = opts.users_fx;
     }
     async startSignUp(opts) {
         await this.auth.signUp({
@@ -31,31 +39,44 @@ export class SessionFX {
         });
     }
     async signIn(opts) {
-        const email = opts.mode === "email"
+        const email = opts.mode === SignInMode.Email
             ? opts.identifier
-            : await this.users.resolveUsername({
+            : await this.users_fx.resolveUsername({
                 username: opts.identifier,
             });
         await this.signInWithEmail({
             email,
             password: opts.password,
+            connection: opts.connection,
         });
     }
     async signInWithEmail(opts) {
-        await this.auth.signIn(opts);
+        await this.auth.signIn({
+            email: opts.email,
+            password: opts.password,
+        });
+        await this.connections.insertOneConnection({
+            in: opts.connection,
+        });
         await this.users.sync();
     }
     async signOut() {
         await this.auth.signOut();
     }
     async forgotPassword(opts) {
-        await this.users.forgotPassword(opts);
+        await this.users.forgotPassword({
+            email: opts.email,
+        });
     }
     async sendSignInLink(opts) {
-        await this.users.sendSignInLink(opts);
+        await this.users.sendSignInLink({
+            email: opts.email,
+        });
     }
     async sendEmailVerification(opts) {
-        await this.users.sendEmailVerification(opts);
+        await this.users.sendEmailVerification({
+            language: opts.language,
+        });
     }
     async checkEmailVerification() {
         await this.auth.reloadUser();

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

@@ -0,0 +1,70 @@
+import { type Object as StorageObject, type PLStorageDownload, type RPStorageUpload } from "@fabriktor/schema";
+import type { OperationResultOf, StorageCollection, StorageOperator, StorageUploadFile, UploadStorageOptions, OptionalField } from "@fabriktor/client";
+export declare const StorageUploadModeration: {
+    readonly Clean: "clean";
+    readonly ContainsForbidden: "contains_forbidden";
+    readonly AllForbidden: "all_forbidden";
+};
+export type StorageUploadModeration = (typeof StorageUploadModeration)[keyof typeof StorageUploadModeration];
+export declare const StorageDualUploadStatus: {
+    readonly ChatOnly: "chat_only";
+    readonly Complete: "complete";
+    readonly Partial: "partial";
+};
+export type StorageDualUploadStatus = (typeof StorageDualUploadStatus)[keyof typeof StorageDualUploadStatus];
+export type StorageFXOptions = {
+    storage: StorageOperator;
+};
+export type UploadObjectsOptions = UploadStorageOptions & {
+    col: StorageCollection;
+};
+export type DownloadObjectsOptions = OptionalField<PLStorageDownload, "mime_prefix"> & {
+    col: StorageCollection;
+};
+export type UploadUserObjectsOptions = {
+    user_id: string;
+    uploader_id?: string;
+    full_quality?: boolean;
+    files: StorageUploadFile[];
+};
+export type UploadChatObjectsOptions = {
+    chat_id: string;
+    user_id?: string;
+    uploader_id?: string;
+    full_quality?: boolean;
+    files: StorageUploadFile[];
+    save_to_personal_box?: boolean;
+};
+export type StorageUploadResult = {
+    raw: OperationResultOf<RPStorageUpload>;
+    moderation: StorageUploadModeration;
+    contains_forbidden: boolean;
+    all_forbidden: boolean;
+};
+export type UploadChatObjectsResult = {
+    status: typeof StorageDualUploadStatus.ChatOnly;
+    chat: StorageUploadResult;
+} | {
+    status: typeof StorageDualUploadStatus.Complete;
+    chat: StorageUploadResult;
+    personal_box: StorageUploadResult;
+} | {
+    status: typeof StorageDualUploadStatus.Partial;
+    chat: StorageUploadResult;
+    personal_box_error: unknown;
+};
+export interface StorageFXOperator {
+    uploadObjects(opts: UploadObjectsOptions): Promise<StorageUploadResult>;
+    downloadObjects(opts: DownloadObjectsOptions): Promise<OperationResultOf<StorageObject[]>>;
+    uploadUserObjects(opts: UploadUserObjectsOptions): Promise<StorageUploadResult>;
+    uploadChatObjects(opts: UploadChatObjectsOptions): Promise<UploadChatObjectsResult>;
+}
+export declare class StorageFX implements StorageFXOperator {
+    private storage;
+    constructor(opts: StorageFXOptions);
+    uploadObjects(opts: UploadObjectsOptions): Promise<StorageUploadResult>;
+    downloadObjects(opts: DownloadObjectsOptions): Promise<OperationResultOf<StorageObject[]>>;
+    uploadUserObjects(opts: UploadUserObjectsOptions): Promise<StorageUploadResult>;
+    uploadChatObjects(opts: UploadChatObjectsOptions): Promise<UploadChatObjectsResult>;
+}
+export declare function newStorageFX(opts: StorageFXOptions): StorageFX;

package/dist/src/storage/storage.js

@@ -0,0 +1,225 @@
+// 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 { ColStorageChat, ColStorageUsers, } from "@fabriktor/schema";
+import { errRequired, errValidation } from "../core/err.js";
+const maxUploadFiles = 20;
+const maxUploadBytes = 1024 * 1024 * 1024;
+const mimePrefixAll = "";
+const extensionHEIC = ".heic";
+const extensionHEIF = ".heif";
+const mimeImageHEIC = "image/heic";
+const mimeImageHEIF = "image/heif";
+const mimeImageHEICSequence = "image/heic-sequence";
+const mimeImageHEIFSequence = "image/heif-sequence";
+const msgOwnerIDRequired = "Owner ID is required.";
+const msgChatIDRequired = "Chat ID is required.";
+const msgUserIDRequired = "User ID is required.";
+const msgUploadFilesRequired = "At least one file is required.";
+const msgUploadTooManyFiles = "Upload supports at most 20 files.";
+const msgUploadTooLarge = "Combined upload size cannot exceed 1 GB.";
+const msgHEICUnsupported = "HEIC and HEIF files must be converted to JPEG or PNG before upload.";
+export const StorageUploadModeration = {
+    Clean: "clean",
+    ContainsForbidden: "contains_forbidden",
+    AllForbidden: "all_forbidden",
+};
+export const StorageDualUploadStatus = {
+    ChatOnly: "chat_only",
+    Complete: "complete",
+    Partial: "partial",
+};
+export class StorageFX {
+    storage;
+    constructor(opts) {
+        this.storage = opts.storage;
+    }
+    async uploadObjects(opts) {
+        validateUpload(opts);
+        const out = await this.storage.upload(opts.col, {
+            owner_id: opts.owner_id,
+            uploader_id: opts.uploader_id,
+            full_quality: opts.full_quality,
+            files: opts.files,
+        });
+        return uploadResult(out);
+    }
+    async downloadObjects(opts) {
+        const owner_id = opts.owner_id.trim();
+        if (owner_id === "") {
+            throw errRequired({
+                field: "owner_id",
+                msg: msgOwnerIDRequired,
+            });
+        }
+        const { col, mime_prefix, ...input } = opts;
+        return await this.storage.download(col, {
+            ...input,
+            owner_id,
+            mime_prefix: mime_prefix?.trim() ?? mimePrefixAll,
+        });
+    }
+    async uploadUserObjects(opts) {
+        const user_id = opts.user_id.trim();
+        if (user_id === "") {
+            throw errRequired({
+                field: "user_id",
+                msg: msgUserIDRequired,
+            });
+        }
+        return await this.uploadObjects({
+            col: ColStorageUsers,
+            owner_id: user_id,
+            uploader_id: opts.uploader_id,
+            full_quality: opts.full_quality,
+            files: opts.files,
+        });
+    }
+    async uploadChatObjects(opts) {
+        const chat_id = opts.chat_id.trim();
+        if (chat_id === "") {
+            throw errRequired({
+                field: "chat_id",
+                msg: msgChatIDRequired,
+            });
+        }
+        let personal_box_user_id;
+        if (opts.save_to_personal_box) {
+            const user_id = opts.user_id?.trim() ?? "";
+            if (user_id === "") {
+                throw errRequired({
+                    field: "user_id",
+                    msg: msgUserIDRequired,
+                });
+            }
+            personal_box_user_id = user_id;
+        }
+        const chat = await this.uploadObjects({
+            col: ColStorageChat,
+            owner_id: chat_id,
+            uploader_id: opts.uploader_id,
+            full_quality: opts.full_quality,
+            files: opts.files,
+        });
+        if (personal_box_user_id === undefined) {
+            return {
+                status: StorageDualUploadStatus.ChatOnly,
+                chat,
+            };
+        }
+        try {
+            const personal_box = await this.uploadUserObjects({
+                user_id: personal_box_user_id,
+                uploader_id: opts.uploader_id,
+                full_quality: opts.full_quality,
+                files: opts.files,
+            });
+            return {
+                status: StorageDualUploadStatus.Complete,
+                chat,
+                personal_box,
+            };
+        }
+        catch (err) {
+            return {
+                status: StorageDualUploadStatus.Partial,
+                chat,
+                personal_box_error: err,
+            };
+        }
+    }
+}
+export function newStorageFX(opts) {
+    return new StorageFX(opts);
+}
+function validateUpload(opts) {
+    if (opts.owner_id.trim() === "") {
+        throw errRequired({
+            field: "owner_id",
+            msg: msgOwnerIDRequired,
+        });
+    }
+    if (opts.files.length === 0) {
+        throw errRequired({
+            field: "files",
+            msg: msgUploadFilesRequired,
+        });
+    }
+    if (opts.files.length > maxUploadFiles) {
+        throw errValidation({
+            field: "files",
+            msg: msgUploadTooManyFiles,
+        });
+    }
+    if (uploadSize(opts.files) > maxUploadBytes) {
+        throw errValidation({
+            field: "files",
+            msg: msgUploadTooLarge,
+        });
+    }
+    if (opts.files.some(isHEIC)) {
+        throw errValidation({
+            field: "files",
+            msg: msgHEICUnsupported,
+        });
+    }
+}
+function uploadSize(files) {
+    let out = 0;
+    for (const f of files) {
+        out += fileSize(f);
+    }
+    return out;
+}
+function fileSize(f) {
+    if ("blob" in f) {
+        return f.blob.size;
+    }
+    return f.size;
+}
+function isHEIC(f) {
+    const name = fileName(f).toLowerCase();
+    const mime = fileMIME(f).toLowerCase();
+    return (name.endsWith(extensionHEIC) ||
+        name.endsWith(extensionHEIF) ||
+        mime === mimeImageHEIC ||
+        mime === mimeImageHEIF ||
+        mime === mimeImageHEICSequence ||
+        mime === mimeImageHEIFSequence);
+}
+function fileName(f) {
+    if ("blob" in f) {
+        return f.filename;
+    }
+    return f.name;
+}
+function fileMIME(f) {
+    if ("blob" in f) {
+        return f.blob.type;
+    }
+    return f.type;
+}
+function uploadResult(raw) {
+    const contains_forbidden = raw.value?.contains_forbidden ?? false;
+    const all_forbidden = raw.value?.all_forbidden ?? false;
+    return {
+        raw,
+        moderation: uploadModeration({
+            contains_forbidden,
+            all_forbidden,
+        }),
+        contains_forbidden,
+        all_forbidden,
+    };
+}
+function uploadModeration(opts) {
+    if (opts.all_forbidden) {
+        return StorageUploadModeration.AllForbidden;
+    }
+    if (opts.contains_forbidden) {
+        return StorageUploadModeration.ContainsForbidden;
+    }
+    return StorageUploadModeration.Clean;
+}

package/dist/src/users/users.d.ts

@@ -1,45 +1,26 @@
-import type { InUser, OperationResult, PLUsersVerifyEmail, PLUsersContactList, PLUsersForgotPassword, PLUsersResolveUsername, PLUsersSendCode, PLUsersSignInLink, PLUsersUsername, PLUsersVerifyCode, UpsertResult, User } from "@fabriktor/schema";
-import type { Op, TmpPhonesOperator, TmpUsernamesOperator, UsernameVerification, UsersOperator, GetByUIDOptions, SearchOptions } from "@fabriktor/client";
+import type { PLUsersResolveUsername, PLUsersSendCode, PLUsersUsername, PLUsersVerifyCode } from "@fabriktor/schema";
+import type { OperationResultOf, TmpPhonesOperator, TmpUsernamesOperator, UsernameVerification, UsersOperator } from "@fabriktor/client";
 export type UsersFXOptions = {
     users: UsersOperator;
     tmp_usernames: TmpUsernamesOperator;
     tmp_phones: TmpPhonesOperator;
 };
-export type BootstrapOptions = {
-    in: InUser;
-};
 export interface UsersFXOperator {
-    bootstrap(opts: BootstrapOptions): Promise<Op<UpsertResult>>;
-    sync(): Promise<OperationResult>;
-    sendEmailVerification(opts: PLUsersVerifyEmail): Promise<void>;
-    forgotPassword(opts: PLUsersForgotPassword): Promise<void>;
-    sendSignInLink(opts: PLUsersSignInLink): Promise<void>;
     resolveUsername(opts: PLUsersResolveUsername): Promise<string>;
-    verifyUsername(opts: PLUsersUsername): Promise<Op<UsernameVerification>>;
-    generateUsernames(opts: PLUsersUsername): Promise<Op<UsernameVerification>>;
+    verifyUsername(opts: PLUsersUsername): Promise<OperationResultOf<UsernameVerification>>;
+    generateUsernames(opts: PLUsersUsername): Promise<OperationResultOf<UsernameVerification>>;
     sendPhoneCode(opts: PLUsersSendCode): Promise<void>;
     verifyPhoneCode(opts: PLUsersVerifyCode): Promise<void>;
-    match(opts: PLUsersContactList): Promise<Op<User[]>>;
-    search(opts: SearchOptions): Promise<Op<User[]>>;
-    getByUID(opts: GetByUIDOptions): Promise<Op<User[]>>;
 }
 export declare class UsersFX implements UsersFXOperator {
     private users;
     private tmp_usernames;
     private tmp_phones;
     constructor(opts: UsersFXOptions);
-    bootstrap(opts: BootstrapOptions): Promise<Op<UpsertResult>>;
-    sync(): Promise<OperationResult>;
-    sendEmailVerification(opts: PLUsersVerifyEmail): Promise<void>;
-    forgotPassword(opts: PLUsersForgotPassword): Promise<void>;
-    sendSignInLink(opts: PLUsersSignInLink): Promise<void>;
     resolveUsername(opts: PLUsersResolveUsername): Promise<string>;
-    verifyUsername(opts: PLUsersUsername): Promise<Op<UsernameVerification>>;
-    generateUsernames(opts: PLUsersUsername): Promise<Op<UsernameVerification>>;
+    verifyUsername(opts: PLUsersUsername): Promise<OperationResultOf<UsernameVerification>>;
+    generateUsernames(opts: PLUsersUsername): Promise<OperationResultOf<UsernameVerification>>;
     sendPhoneCode(opts: PLUsersSendCode): Promise<void>;
     verifyPhoneCode(opts: PLUsersVerifyCode): Promise<void>;
-    match(opts: PLUsersContactList): Promise<Op<User[]>>;
-    search(opts: SearchOptions): Promise<Op<User[]>>;
-    getByUID(opts: GetByUIDOptions): Promise<Op<User[]>>;
 }
 export declare function newUsersFX(opts: UsersFXOptions): UsersFX;

package/dist/src/users/users.js

@@ -3,9 +3,13 @@
 // 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 { errPhoneCodeRequired, errPhoneRequired, errUsernameInvalid, errUsernameResolveFailed, } from "../core/err.js";
+import { errRequired, errResolveFailed, errValidation, } from "../core/err.js";
 import { normalizePhone, normalizePhoneCode, validatePhone, validatePhoneCode, } from "./phone.js";
 import { normalizeUsername, validateUsernameFormat } from "./username.js";
+const msgUnableToResolveUsername = "Unable to resolve username.";
+const msgPhoneRequired = "Phone number is required.";
+const msgPhoneCodeRequired = "Verification code is required.";
+const resourceUsername = "username";
 export class UsersFX {
     users;
     tmp_usernames;
@@ -15,58 +19,22 @@ export class UsersFX {
         this.tmp_usernames = opts.tmp_usernames;
         this.tmp_phones = opts.tmp_phones;
     }
-    async bootstrap(opts) {
-        return await this.users.bootstrap({
-            in: opts.in,
-        });
-    }
-    async sync() {
-        return await this.users.sync();
-    }
-    async sendEmailVerification(opts) {
-        return await this.users.sendEmailVerification(opts);
-    }
-    async forgotPassword(opts) {
-        return await this.users.forgotPassword({
-            email: opts.email,
-        });
-    }
-    async sendSignInLink(opts) {
-        return await this.users.sendSignInLink({
-            email: opts.email,
-        });
-    }
-    // public async resolveUsername(opts: PLUsersResolveUsername): Promise<string> {
-    //   const username = normalizeUsername(opts.username);
-    //   const out = await this.users.resolveUsername({
-    //     username,
-    //   });
-    //   if (out.value === undefined) {
-    //     throw errUsernameResolveFailed();
-    //   }
-    //   return out.value;
-    // }
     async resolveUsername(opts) {
         const username = normalizeUsername(opts.username);
-        console.log("[fx/users.resolveUsername] normalized", {
-            input: opts.username,
-            username,
-        });
         const out = await this.users.resolveUsername({
             username,
         });
-        console.log("[fx/users.resolveUsername] response", out);
         if (out.value === undefined ||
             out.value.trim() === "" ||
             !out.value.includes("@")) {
-            throw errUsernameResolveFailed();
+            throw errUsernameResolveFailed("username");
         }
         return out.value;
     }
     async verifyUsername(opts) {
         const check = validateUsernameFormat(opts.to_validate);
         if (!check.valid) {
-            throw errUsernameInvalid(check.error);
+            throw errUsernameInvalid("to_validate", check.error);
         }
         return await this.tmp_usernames.verify({
             words: opts.words,
@@ -82,7 +50,7 @@ export class UsersFX {
     async sendPhoneCode(opts) {
         const phone = normalizePhone(opts.phone);
         if (!validatePhone(phone)) {
-            throw errPhoneRequired();
+            throw errPhoneRequired("phone");
         }
         return await this.tmp_phones.send({
             phone,
@@ -92,33 +60,42 @@ export class UsersFX {
         const phone = normalizePhone(opts.phone);
         const code = normalizePhoneCode(opts.code);
         if (!validatePhone(phone)) {
-            throw errPhoneRequired();
+            throw errPhoneRequired("phone");
         }
         if (!validatePhoneCode(code)) {
-            throw errPhoneCodeRequired();
+            throw errPhoneCodeRequired("code");
         }
         return await this.tmp_phones.verify({
             phone,
             code,
         });
     }
-    async match(opts) {
-        return await this.users.match({
-            contacts: opts.contacts,
-        });
-    }
-    async search(opts) {
-        return await this.users.search({
-            q: opts.q,
-            limit: opts.limit,
-        });
-    }
-    async getByUID(opts) {
-        return await this.users.getByUID({
-            uid: opts.uid,
-        });
-    }
 }
 export function newUsersFX(opts) {
     return new UsersFX(opts);
 }
+function errUsernameResolveFailed(field) {
+    return errResolveFailed({
+        resource: resourceUsername,
+        field,
+        msg: msgUnableToResolveUsername,
+    });
+}
+function errUsernameInvalid(field, msg) {
+    return errValidation({
+        field,
+        msg,
+    });
+}
+function errPhoneRequired(field) {
+    return errRequired({
+        field,
+        msg: msgPhoneRequired,
+    });
+}
+function errPhoneCodeRequired(field) {
+    return errRequired({
+        field,
+        msg: msgPhoneCodeRequired,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "^0.0.25",
-    "@fabriktor/schema": "^0.0.18"
+    "@fabriktor/client": "0.0.38",
+    "@fabriktor/schema": "0.0.29"
   }
 }