@fabriktor/fx 0.0.31 → 0.0.33

package/dist/src/session/session.d.ts

@@ -1,18 +1,32 @@
-import type { InUser, PLUsersForgotPassword, PLUsersSignInLink, PLUsersVerifyEmail, UpsertResult } from "@fabriktor/schema";
-import type { BootstrapOptions, OperationResultOf, UsersOperator } from "@fabriktor/client";
+import type { UpsertResult } from "@fabriktor/schema";
+import type { BootstrapOptions, ConnectionsOperator, OperationResultOf, UsersOperator } from "@fabriktor/client";
 import type { AuthEmailOptions, AuthOperator } from "../auth/auth.js";
 import type { UsersFXOperator } from "../users/users.js";
-export type SignInMode = "email" | "username";
+type ConnectionInsert = Parameters<ConnectionsOperator["insertOneConnection"]>[0]["in"];
+type BootstrapInput = BootstrapOptions["in"];
+export declare const SignInMode: {
+    readonly Email: "email";
+    readonly Username: "username";
+};
+export type SignInMode = (typeof SignInMode)[keyof typeof SignInMode];
 export type SignInOptions = {
     mode: SignInMode;
     identifier: string;
     password: string;
+    connection: ConnectionInsert;
+};
+export type SignInWithEmailOptions = AuthEmailOptions & {
+    connection: ConnectionInsert;
 };
 export type SignUpAndBootstrapOptions = AuthEmailOptions & {
-    in: InUser;
+    in: BootstrapInput;
 };
+export type ForgotPasswordOptions = Parameters<UsersOperator["forgotPassword"]>[0];
+export type SendSignInLinkOptions = Parameters<UsersOperator["sendSignInLink"]>[0];
+export type SendEmailVerificationOptions = Parameters<UsersOperator["sendEmailVerification"]>[0];
 export type SessionFXOptions = {
     auth: AuthOperator;
+    connections: ConnectionsOperator;
     users: UsersOperator;
     users_fx: UsersFXOperator;
 };
@@ -21,27 +35,29 @@ export interface SessionFXOperator {
     finishSignUp(opts: BootstrapOptions): Promise<OperationResultOf<UpsertResult>>;
     signUpAndBootstrap(opts: SignUpAndBootstrapOptions): Promise<OperationResultOf<UpsertResult>>;
     signIn(opts: SignInOptions): Promise<void>;
-    signInWithEmail(opts: AuthEmailOptions): Promise<void>;
+    signInWithEmail(opts: SignInWithEmailOptions): Promise<void>;
     signOut(): Promise<void>;
-    forgotPassword(opts: PLUsersForgotPassword): Promise<void>;
-    sendSignInLink(opts: PLUsersSignInLink): Promise<void>;
-    sendEmailVerification(opts: PLUsersVerifyEmail): Promise<void>;
+    forgotPassword(opts: ForgotPasswordOptions): Promise<void>;
+    sendSignInLink(opts: SendSignInLinkOptions): Promise<void>;
+    sendEmailVerification(opts: SendEmailVerificationOptions): Promise<void>;
     checkEmailVerification(): Promise<boolean>;
 }
 export declare class SessionFX implements SessionFXOperator {
     private auth;
+    private connections;
     private users;
-    private users_fx;
+    private usersFX;
     constructor(opts: SessionFXOptions);
     startSignUp(opts: AuthEmailOptions): Promise<void>;
     finishSignUp(opts: BootstrapOptions): Promise<OperationResultOf<UpsertResult>>;
     signUpAndBootstrap(opts: SignUpAndBootstrapOptions): Promise<OperationResultOf<UpsertResult>>;
     signIn(opts: SignInOptions): Promise<void>;
-    signInWithEmail(opts: AuthEmailOptions): Promise<void>;
+    signInWithEmail(opts: SignInWithEmailOptions): Promise<void>;
     signOut(): Promise<void>;
-    forgotPassword(opts: PLUsersForgotPassword): Promise<void>;
-    sendSignInLink(opts: PLUsersSignInLink): Promise<void>;
-    sendEmailVerification(opts: PLUsersVerifyEmail): Promise<void>;
+    forgotPassword(opts: ForgotPasswordOptions): Promise<void>;
+    sendSignInLink(opts: SendSignInLinkOptions): Promise<void>;
+    sendEmailVerification(opts: SendEmailVerificationOptions): Promise<void>;
     checkEmailVerification(): Promise<boolean>;
 }
 export declare function newSessionFX(opts: SessionFXOptions): SessionFX;
+export {};

package/dist/src/session/session.js

@@ -3,14 +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;
+    usersFX;
     constructor(opts) {
         this.auth = opts.auth;
+        this.connections = opts.connections;
         this.users = opts.users;
-        this.users_fx = opts.users_fx;
+        this.usersFX = opts.users_fx;
     }
     async startSignUp(opts) {
         await this.auth.signUp({
@@ -33,37 +39,38 @@ export class SessionFX {
         });
     }
     async signIn(opts) {
-        const email = opts.mode === "email"
+        const email = opts.mode === SignInMode.Email
             ? opts.identifier
-            : await this.users_fx.resolveUsername({
+            : await this.usersFX.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({
-            email: opts.email,
-        });
+        await this.users.forgotPassword(opts);
     }
     async sendSignInLink(opts) {
-        await this.users.sendSignInLink({
-            email: opts.email,
-        });
+        await this.users.sendSignInLink(opts);
     }
     async sendEmailVerification(opts) {
-        await this.users.sendEmailVerification({
-            language: opts.language,
-        });
+        await this.users.sendEmailVerification(opts);
     }
     async checkEmailVerification() {
         await this.auth.reloadUser();

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

@@ -0,0 +1,79 @@
+import { type Object as StorageObject, type RPStorageUpload } from "@fabriktor/schema";
+import type { OperationResultOf, OptionalField, StorageCollection, StorageOperator, StorageUploadFile, UploadStorageOptions } from "@fabriktor/client";
+type StorageDownloadOptions = Parameters<StorageOperator["download"]>[1];
+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 StoragePersonalBoxUploadStatus: {
+    readonly PrimaryOnly: "primary_only";
+    readonly Complete: "complete";
+    readonly Partial: "partial";
+};
+export type StoragePersonalBoxUploadStatus = (typeof StoragePersonalBoxUploadStatus)[keyof typeof StoragePersonalBoxUploadStatus];
+export type StorageFXOptions = {
+    storage: StorageOperator;
+};
+export type UploadObjectsOptions = UploadStorageOptions & {
+    col: StorageCollection;
+};
+export type UploadObjectsWithPersonalBoxOptions = UploadObjectsOptions & {
+    user_id?: string;
+    save_to_personal_box?: boolean;
+};
+export type DownloadObjectsOptions = OptionalField<StorageDownloadOptions, "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 StoragePersonalBoxUploadResult = {
+    status: typeof StoragePersonalBoxUploadStatus.PrimaryOnly;
+    primary: StorageUploadResult;
+} | {
+    status: typeof StoragePersonalBoxUploadStatus.Complete;
+    primary: StorageUploadResult;
+    personal_box: StorageUploadResult;
+} | {
+    status: typeof StoragePersonalBoxUploadStatus.Partial;
+    primary: StorageUploadResult;
+    personal_box_error: unknown;
+};
+export type UploadChatObjectsResult = StoragePersonalBoxUploadResult;
+export interface StorageFXOperator {
+    uploadObjects(opts: UploadObjectsOptions): Promise<StorageUploadResult>;
+    uploadObjectsWithPersonalBox(opts: UploadObjectsWithPersonalBoxOptions): Promise<StoragePersonalBoxUploadResult>;
+    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>;
+    uploadObjectsWithPersonalBox(opts: UploadObjectsWithPersonalBoxOptions): Promise<StoragePersonalBoxUploadResult>;
+    downloadObjects(opts: DownloadObjectsOptions): Promise<OperationResultOf<StorageObject[]>>;
+    uploadUserObjects(opts: UploadUserObjectsOptions): Promise<StorageUploadResult>;
+    uploadChatObjects(opts: UploadChatObjectsOptions): Promise<UploadChatObjectsResult>;
+}
+export declare function newStorageFX(opts: StorageFXOptions): StorageFX;
+export {};

package/dist/src/storage/storage.js

@@ -0,0 +1,240 @@
+// 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 StoragePersonalBoxUploadStatus = {
+    PrimaryOnly: "primary_only",
+    Complete: "complete",
+    Partial: "partial",
+};
+export class StorageFX {
+    storage;
+    constructor(opts) {
+        this.storage = opts.storage;
+    }
+    async uploadObjects(opts) {
+        validateUpload(opts);
+        const owner_id = opts.owner_id.trim();
+        const out = await this.storage.upload(opts.col, {
+            owner_id,
+            uploader_id: opts.uploader_id,
+            full_quality: opts.full_quality,
+            files: opts.files,
+        });
+        return uploadResult(out);
+    }
+    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,
+            files: opts.files,
+        });
+        if (personal_box_user_id === undefined) {
+            return {
+                status: StoragePersonalBoxUploadStatus.PrimaryOnly,
+                primary,
+            };
+        }
+        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: StoragePersonalBoxUploadStatus.Complete,
+                primary,
+                personal_box,
+            };
+        }
+        catch (err) {
+            return {
+                status: StoragePersonalBoxUploadStatus.Partial,
+                primary,
+                personal_box_error: err,
+            };
+        }
+    }
+    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,
+            });
+        }
+        return await this.uploadObjectsWithPersonalBox({
+            col: ColStorageChat,
+            owner_id: chat_id,
+            user_id: opts.user_id,
+            uploader_id: opts.uploader_id,
+            full_quality: opts.full_quality,
+            files: opts.files,
+            save_to_personal_box: opts.save_to_personal_box,
+        });
+    }
+}
+export function newStorageFX(opts) {
+    return new StorageFX(opts);
+}
+function personalBoxUserID(opts) {
+    if (!opts.save_to_personal_box) {
+        return undefined;
+    }
+    const user_id = opts.user_id?.trim();
+    if (user_id === undefined || user_id === "") {
+        throw errRequired({
+            field: "user_id",
+            msg: msgUserIDRequired,
+        });
+    }
+    return user_id;
+}
+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/timesheets/timesheets.d.ts

@@ -0,0 +1,91 @@
+import { type Date as SchemaDate, type OperationResult, type WeekSheet } from "@fabriktor/schema";
+import type { TimesheetsOperator } from "@fabriktor/client";
+type PunchPayload = Parameters<TimesheetsOperator["punch"]>[0];
+export type TimesheetsFXOptions = {
+    timesheets: TimesheetsOperator;
+};
+export type PunchContext = Pick<PunchPayload, "timezone" | "location_id" | "employer_id">;
+export type PunchInOptions = PunchContext & {
+    explicit_date?: SchemaDate;
+};
+export type PunchOutOptions = PunchContext & {
+    total_pause_minutes: number;
+    total_meal_minutes: number;
+    explicit_date?: SchemaDate;
+};
+export type RideInOptions = PunchContext & {
+    explicit_date?: SchemaDate;
+};
+export type RideOutOptions = PunchContext & {
+    explicit_date?: SchemaDate;
+};
+export type ReplaceDayOptions = PunchContext & {
+    punch_in_date: SchemaDate;
+    punch_out_date: SchemaDate;
+    total_pause_minutes: number;
+    total_meal_minutes: number;
+};
+export type ReplaceDayResult = {
+    punch_in: OperationResult;
+    punch_out: OperationResult;
+};
+export type DeleteDayOptions = PunchContext & {
+    explicit_date?: SchemaDate;
+};
+export type CreateBlankWeekSheetOptions = PunchContext & {
+    explicit_date?: SchemaDate;
+};
+export type PunchControlsOptions = {
+    week_sheet?: WeekSheet;
+    week_day: number;
+};
+export type PunchControls = {
+    can_punch_in: boolean;
+    can_punch_out: boolean;
+    can_ride_in: boolean;
+    can_ride_out: boolean;
+};
+export type SyncWeekOptions = {
+    from: WeekSheet;
+    to: WeekSheet[];
+};
+export type SyncDaysOptions = SyncWeekOptions & {
+    days: number[];
+};
+export type ApproveWeekSheetsOptions = {
+    employer_id: string;
+    week_sheets: WeekSheet[];
+};
+export interface TimesheetsFXOperator {
+    punchControls(opts: PunchControlsOptions): PunchControls;
+    punchIn(opts: PunchInOptions): Promise<OperationResult>;
+    punchOut(opts: PunchOutOptions): Promise<OperationResult>;
+    rideIn(opts: RideInOptions): Promise<OperationResult>;
+    rideOut(opts: RideOutOptions): Promise<OperationResult>;
+    replaceDay(opts: ReplaceDayOptions): Promise<ReplaceDayResult>;
+    deleteDay(opts: DeleteDayOptions): Promise<OperationResult>;
+    createBlankWeekSheet(opts: CreateBlankWeekSheetOptions): Promise<OperationResult>;
+    syncWeek(opts: SyncWeekOptions): Promise<void>;
+    syncDays(opts: SyncDaysOptions): Promise<void>;
+    approveWeekSheets(opts: ApproveWeekSheetsOptions): Promise<void>;
+}
+export declare class TimesheetsFX implements TimesheetsFXOperator {
+    private timesheets;
+    private punch_in_progress;
+    constructor(opts: TimesheetsFXOptions);
+    punchControls(opts: PunchControlsOptions): PunchControls;
+    punchIn(opts: PunchInOptions): Promise<OperationResult>;
+    punchOut(opts: PunchOutOptions): Promise<OperationResult>;
+    rideIn(opts: RideInOptions): Promise<OperationResult>;
+    rideOut(opts: RideOutOptions): Promise<OperationResult>;
+    replaceDay(opts: ReplaceDayOptions): Promise<ReplaceDayResult>;
+    deleteDay(opts: DeleteDayOptions): Promise<OperationResult>;
+    createBlankWeekSheet(opts: CreateBlankWeekSheetOptions): Promise<OperationResult>;
+    syncWeek(opts: SyncWeekOptions): Promise<void>;
+    syncDays(opts: SyncDaysOptions): Promise<void>;
+    approveWeekSheets(opts: ApproveWeekSheetsOptions): Promise<void>;
+    private syncSheets;
+    private runPunch;
+}
+export declare function newTimesheetsFX(opts: TimesheetsFXOptions): TimesheetsFX;
+export {};