@fabriktor/fx 0.0.32 → 0.0.33

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

@@ -1,7 +1,9 @@
-import type { InConnection, InUser, PLUsersForgotPassword, PLUsersSignInLink, PLUsersVerifyEmail, UpsertResult } from "@fabriktor/schema";
+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";
+type ConnectionInsert = Parameters<ConnectionsOperator["insertOneConnection"]>[0]["in"];
+type BootstrapInput = BootstrapOptions["in"];
 export declare const SignInMode: {
     readonly Email: "email";
     readonly Username: "username";
@@ -11,14 +13,17 @@ export type SignInOptions = {
     mode: SignInMode;
     identifier: string;
     password: string;
-    connection: InConnection;
+    connection: ConnectionInsert;
 };
 export type SignInWithEmailOptions = AuthEmailOptions & {
-    connection: InConnection;
+    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;
@@ -32,16 +37,16 @@ export interface SessionFXOperator {
     signIn(opts: SignInOptions): 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>>;
@@ -49,9 +54,10 @@ export declare class SessionFX implements SessionFXOperator {
     signIn(opts: SignInOptions): 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

@@ -11,12 +11,12 @@ 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({
@@ -41,7 +41,7 @@ export class SessionFX {
     async signIn(opts) {
         const email = opts.mode === SignInMode.Email
             ? opts.identifier
-            : await this.users_fx.resolveUsername({
+            : await this.usersFX.resolveUsername({
                 username: opts.identifier,
             });
         await this.signInWithEmail({
@@ -64,19 +64,13 @@ export class SessionFX {
         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

@@ -1,24 +1,29 @@
-import { type Object as StorageObject, type PLStorageDownload, type RPStorageUpload } from "@fabriktor/schema";
-import type { OperationResultOf, StorageCollection, StorageOperator, StorageUploadFile, UploadStorageOptions, OptionalField } from "@fabriktor/client";
+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 StorageDualUploadStatus: {
-    readonly ChatOnly: "chat_only";
+export declare const StoragePersonalBoxUploadStatus: {
+    readonly PrimaryOnly: "primary_only";
     readonly Complete: "complete";
     readonly Partial: "partial";
 };
-export type StorageDualUploadStatus = (typeof StorageDualUploadStatus)[keyof typeof StorageDualUploadStatus];
+export type StoragePersonalBoxUploadStatus = (typeof StoragePersonalBoxUploadStatus)[keyof typeof StoragePersonalBoxUploadStatus];
 export type StorageFXOptions = {
     storage: StorageOperator;
 };
 export type UploadObjectsOptions = UploadStorageOptions & {
     col: StorageCollection;
 };
-export type DownloadObjectsOptions = OptionalField<PLStorageDownload, "mime_prefix"> & {
+export type UploadObjectsWithPersonalBoxOptions = UploadObjectsOptions & {
+    user_id?: string;
+    save_to_personal_box?: boolean;
+};
+export type DownloadObjectsOptions = OptionalField<StorageDownloadOptions, "mime_prefix"> & {
     col: StorageCollection;
 };
 export type UploadUserObjectsOptions = {
@@ -41,20 +46,22 @@ export type StorageUploadResult = {
     contains_forbidden: boolean;
     all_forbidden: boolean;
 };
-export type UploadChatObjectsResult = {
-    status: typeof StorageDualUploadStatus.ChatOnly;
-    chat: StorageUploadResult;
+export type StoragePersonalBoxUploadResult = {
+    status: typeof StoragePersonalBoxUploadStatus.PrimaryOnly;
+    primary: StorageUploadResult;
 } | {
-    status: typeof StorageDualUploadStatus.Complete;
-    chat: StorageUploadResult;
+    status: typeof StoragePersonalBoxUploadStatus.Complete;
+    primary: StorageUploadResult;
     personal_box: StorageUploadResult;
 } | {
-    status: typeof StorageDualUploadStatus.Partial;
-    chat: 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>;
@@ -63,8 +70,10 @@ 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

@@ -26,8 +26,8 @@ export const StorageUploadModeration = {
     ContainsForbidden: "contains_forbidden",
     AllForbidden: "all_forbidden",
 };
-export const StorageDualUploadStatus = {
-    ChatOnly: "chat_only",
+export const StoragePersonalBoxUploadStatus = {
+    PrimaryOnly: "primary_only",
     Complete: "complete",
     Partial: "partial",
 };
@@ -38,14 +38,51 @@ export class StorageFX {
     }
     async uploadObjects(opts) {
         validateUpload(opts);
+        const owner_id = opts.owner_id.trim();
         const out = await this.storage.upload(opts.col, {
-            owner_id: opts.owner_id,
+            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 === "") {
@@ -85,55 +122,33 @@ export class StorageFX {
                 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({
+        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,
         });
-        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 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({

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 {};