@fabriktor/fx 0.0.39 → 0.0.40

package/dist/src/payrolls/payrolls.js

@@ -3,11 +3,245 @@
 // 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 { OwnerIDKey, } from "@fabriktor/schema";
+import { errResolveFailed } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+import { runSearch } from "../core/search.js";
+const resourcePayable = "payable";
+const msgCreatedPayableIDMissing = "Created payable response did not contain an ID.";
+const msgPayableMissing = "Payable could not be resolved after the mutation.";
+const resourcePayroll = "payroll";
+const msgCreatedPayrollIDMissing = "Created payroll response did not contain an ID.";
+const msgPayrollMissing = "Payroll could not be resolved after the mutation.";
+const resourcePayConfig = "pay_config";
+const msgCreatedPayConfigIDMissing = "Created pay config response did not contain an ID.";
+const msgPayConfigMissing = "Pay config could not be resolved after the mutation.";
+const resourceHourBank = "hour_bank";
+const msgCreatedHourBankIDMissing = "Created hour bank response did not contain an ID.";
+const msgHourBankMissing = "Hour bank could not be resolved after the mutation.";
+const resourceAdjustment = "adjustment";
+const msgCreatedAdjustmentIDMissing = "Created adjustment response did not contain an ID.";
+const msgAdjustmentMissing = "Adjustment could not be resolved after the mutation.";
+const resourceAdjustmentFolder = "adjustment_folder";
+const msgCreatedAdjustmentFolderIDMissing = "Created adjustment folder response did not contain an ID.";
+const msgAdjustmentFolderMissing = "Adjustment folder could not be resolved after the mutation.";
+const resourceAdjustmentRecord = "adjustment_record";
+const msgCreatedAdjustmentRecordIDMissing = "Created adjustment record response did not contain an ID.";
+const msgAdjustmentRecordMissing = "Adjustment record could not be resolved after the mutation.";
+const resourceAdjustmentAggregate = "adjustment_aggregate";
+const msgCreatedAdjustmentAggregateIDMissing = "Created adjustment aggregate response did not contain an ID.";
+const msgAdjustmentAggregateMissing = "Adjustment aggregate could not be resolved after the mutation.";
+const resourceEmployeePayConfig = "employee_pay_config";
+const msgCreatedEmployeePayConfigIDMissing = "Created employee pay config response did not contain an ID.";
+const msgEmployeePayConfigMissing = "Employee pay config could not be resolved after the mutation.";
+const resourcePayrollProgram = "payroll_program";
+const msgCreatedPayrollProgramIDMissing = "Created payroll program response did not contain an ID.";
+const msgPayrollProgramMissing = "Payroll program could not be resolved after the mutation.";
 export class PayrollsFX {
     payrolls;
     constructor(opts) {
         this.payrolls = opts.payrolls;
     }
+    async createPayable(opts) {
+        const out = await this.payrolls.insertOnePayable(opts);
+        const id = requiredOperationID(out, msgCreatedPayableIDMissing);
+        return await this.findPayable(id);
+    }
+    async replacePayable(opts) {
+        await this.payrolls.replaceOnePayable(opts);
+        return await this.findPayable(opts.id);
+    }
+    async searchPayables(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyPayables(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPayroll(opts) {
+        const out = await this.payrolls.insertOnePayroll(opts);
+        const id = requiredOperationID(out, msgCreatedPayrollIDMissing);
+        return await this.findPayroll(id);
+    }
+    async replacePayroll(opts) {
+        await this.payrolls.replaceOnePayroll(opts);
+        return await this.findPayroll(opts.id);
+    }
+    async searchPayrolls(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyPayrolls(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPayConfig(opts) {
+        const out = await this.payrolls.insertOnePayConfig(opts);
+        const id = requiredOperationID(out, msgCreatedPayConfigIDMissing);
+        return await this.findPayConfig(id);
+    }
+    async replacePayConfig(opts) {
+        await this.payrolls.replaceOnePayConfig(opts);
+        return await this.findPayConfig(opts.id);
+    }
+    async searchPayConfigs(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyPayConfigs(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createHourBank(opts) {
+        const out = await this.payrolls.insertOneHourBank(opts);
+        const id = requiredOperationID(out, msgCreatedHourBankIDMissing);
+        return await this.findHourBank(id);
+    }
+    async replaceHourBank(opts) {
+        await this.payrolls.replaceOneHourBank(opts);
+        return await this.findHourBank(opts.id);
+    }
+    async searchHourBanks(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyHourBanks(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createAdjustment(opts) {
+        const out = await this.payrolls.insertOneAdjustment(opts);
+        const id = requiredOperationID(out, msgCreatedAdjustmentIDMissing);
+        return await this.findAdjustment(id);
+    }
+    async replaceAdjustment(opts) {
+        await this.payrolls.replaceOneAdjustment(opts);
+        return await this.findAdjustment(opts.id);
+    }
+    async searchAdjustments(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyAdjustments(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createAdjustmentFolder(opts) {
+        const out = await this.payrolls.insertOneAdjustmentFolder(opts);
+        const id = requiredOperationID(out, msgCreatedAdjustmentFolderIDMissing);
+        return await this.findAdjustmentFolder(id);
+    }
+    async replaceAdjustmentFolder(opts) {
+        await this.payrolls.replaceOneAdjustmentFolder(opts);
+        return await this.findAdjustmentFolder(opts.id);
+    }
+    async searchAdjustmentFolders(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyAdjustmentFolders(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createAdjustmentRecord(opts) {
+        const out = await this.payrolls.insertOneAdjustmentRecord(opts);
+        const id = requiredOperationID(out, msgCreatedAdjustmentRecordIDMissing);
+        return await this.findAdjustmentRecord(id);
+    }
+    async replaceAdjustmentRecord(opts) {
+        await this.payrolls.replaceOneAdjustmentRecord(opts);
+        return await this.findAdjustmentRecord(opts.id);
+    }
+    async searchAdjustmentRecords(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyAdjustmentRecords(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createAdjustmentAggregate(opts) {
+        const out = await this.payrolls.insertOneAdjustmentAggregate(opts);
+        const id = requiredOperationID(out, msgCreatedAdjustmentAggregateIDMissing);
+        return await this.findAdjustmentAggregate(id);
+    }
+    async replaceAdjustmentAggregate(opts) {
+        await this.payrolls.replaceOneAdjustmentAggregate(opts);
+        return await this.findAdjustmentAggregate(opts.id);
+    }
+    async searchAdjustmentAggregates(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyAdjustmentAggregates(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createEmployeePayConfig(opts) {
+        const out = await this.payrolls.insertOneEmployeePayConfig(opts);
+        const id = requiredOperationID(out, msgCreatedEmployeePayConfigIDMissing);
+        return await this.findEmployeePayConfig(id);
+    }
+    async replaceEmployeePayConfig(opts) {
+        await this.payrolls.replaceOneEmployeePayConfig(opts);
+        return await this.findEmployeePayConfig(opts.id);
+    }
+    async searchEmployeePayConfigs(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyEmployeePayConfigs(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPayrollProgram(opts) {
+        const out = await this.payrolls.insertOnePayrollProgram(opts);
+        const id = requiredOperationID(out, msgCreatedPayrollProgramIDMissing);
+        return await this.findPayrollProgram(id);
+    }
+    async replacePayrollProgram(opts) {
+        await this.payrolls.replaceOnePayrollProgram(opts);
+        return await this.findPayrollProgram(opts.id);
+    }
+    async searchPayrollPrograms(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payrolls.searchManyPayrollPrograms(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
     async setAdjustmentArchived(opts) {
         return await this.payrolls.replaceOneAdjustment({
             id: opts.id,
@@ -48,6 +282,136 @@ export class PayrollsFX {
             },
         });
     }
+    async findPayable(id) {
+        const out = await this.payrolls.findOnePayable({
+            id,
+        });
+        const payable = out.value;
+        if (payable === undefined) {
+            throw errResolveFailed({
+                resource: resourcePayable,
+                msg: msgPayableMissing,
+            });
+        }
+        return payable;
+    }
+    async findPayroll(id) {
+        const out = await this.payrolls.findOnePayroll({
+            id,
+        });
+        const payroll = out.value;
+        if (payroll === undefined) {
+            throw errResolveFailed({
+                resource: resourcePayroll,
+                msg: msgPayrollMissing,
+            });
+        }
+        return payroll;
+    }
+    async findPayConfig(id) {
+        const out = await this.payrolls.findOnePayConfig({
+            id,
+        });
+        const pay_config = out.value;
+        if (pay_config === undefined) {
+            throw errResolveFailed({
+                resource: resourcePayConfig,
+                msg: msgPayConfigMissing,
+            });
+        }
+        return pay_config;
+    }
+    async findHourBank(id) {
+        const out = await this.payrolls.findOneHourBank({
+            id,
+        });
+        const hour_bank = out.value;
+        if (hour_bank === undefined) {
+            throw errResolveFailed({
+                resource: resourceHourBank,
+                msg: msgHourBankMissing,
+            });
+        }
+        return hour_bank;
+    }
+    async findAdjustment(id) {
+        const out = await this.payrolls.findOneAdjustment({
+            id,
+        });
+        const adjustment = out.value;
+        if (adjustment === undefined) {
+            throw errResolveFailed({
+                resource: resourceAdjustment,
+                msg: msgAdjustmentMissing,
+            });
+        }
+        return adjustment;
+    }
+    async findAdjustmentFolder(id) {
+        const out = await this.payrolls.findOneAdjustmentFolder({
+            id,
+        });
+        const adjustment_folder = out.value;
+        if (adjustment_folder === undefined) {
+            throw errResolveFailed({
+                resource: resourceAdjustmentFolder,
+                msg: msgAdjustmentFolderMissing,
+            });
+        }
+        return adjustment_folder;
+    }
+    async findAdjustmentRecord(id) {
+        const out = await this.payrolls.findOneAdjustmentRecord({
+            id,
+        });
+        const adjustment_record = out.value;
+        if (adjustment_record === undefined) {
+            throw errResolveFailed({
+                resource: resourceAdjustmentRecord,
+                msg: msgAdjustmentRecordMissing,
+            });
+        }
+        return adjustment_record;
+    }
+    async findAdjustmentAggregate(id) {
+        const out = await this.payrolls.findOneAdjustmentAggregate({
+            id,
+        });
+        const adjustment_aggregate = out.value;
+        if (adjustment_aggregate === undefined) {
+            throw errResolveFailed({
+                resource: resourceAdjustmentAggregate,
+                msg: msgAdjustmentAggregateMissing,
+            });
+        }
+        return adjustment_aggregate;
+    }
+    async findEmployeePayConfig(id) {
+        const out = await this.payrolls.findOneEmployeePayConfig({
+            id,
+        });
+        const employee_pay_config = out.value;
+        if (employee_pay_config === undefined) {
+            throw errResolveFailed({
+                resource: resourceEmployeePayConfig,
+                msg: msgEmployeePayConfigMissing,
+            });
+        }
+        return employee_pay_config;
+    }
+    async findPayrollProgram(id) {
+        const out = await this.payrolls.findOnePayrollProgram({
+            id,
+        });
+        const payroll_program = out.value;
+        if (payroll_program === undefined) {
+            throw errResolveFailed({
+                resource: resourcePayrollProgram,
+                msg: msgPayrollProgramMissing,
+            });
+        }
+        return payroll_program;
+    }
 }
 export function newPayrollsFX(opts) {
     return new PayrollsFX(opts);

package/dist/src/preferences/preferences.d.ts

@@ -1,5 +1,41 @@
-import type { OperationResult } from "@fabriktor/schema";
 import type { PreferencesOperator } from "@fabriktor/client";
+import { type OperationResult, type PrefPayment, type PrefClient, type PrefEmployee, type PrefCompany, type PrefVisibility, type PrefLanguage, type PrefNotif, type PrefEmail, type PrefTutorial } from "@fabriktor/schema";
+type PrefPaymentInsertOptions = Parameters<PreferencesOperator["insertOnePrefPayment"]>[0];
+type PrefPaymentReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefPayment"]>[0];
+type PrefClientInsertOptions = Parameters<PreferencesOperator["insertOnePrefClient"]>[0];
+type PrefClientReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefClient"]>[0];
+type PrefEmployeeInsertOptions = Parameters<PreferencesOperator["insertOnePrefEmployee"]>[0];
+type PrefEmployeeReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefEmployee"]>[0];
+type PrefCompanyInsertOptions = Parameters<PreferencesOperator["insertOnePrefCompany"]>[0];
+type PrefCompanyReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefCompany"]>[0];
+type PrefVisibilityInsertOptions = Parameters<PreferencesOperator["insertOnePrefVisibility"]>[0];
+type PrefVisibilityReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefVisibility"]>[0];
+type PrefLanguageInsertOptions = Parameters<PreferencesOperator["insertOnePrefLanguage"]>[0];
+type PrefLanguageReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefLanguage"]>[0];
+type PrefNotifInsertOptions = Parameters<PreferencesOperator["insertOnePrefNotif"]>[0];
+type PrefNotifReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefNotif"]>[0];
+type PrefEmailInsertOptions = Parameters<PreferencesOperator["insertOnePrefEmail"]>[0];
+type PrefEmailReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefEmail"]>[0];
+type PrefTutorialInsertOptions = Parameters<PreferencesOperator["insertOnePrefTutorial"]>[0];
+type PrefTutorialReplaceOptions = Parameters<PreferencesOperator["replaceOnePrefTutorial"]>[0];
+export type CreatePrefPaymentOptions = PrefPaymentInsertOptions;
+export type ReplacePrefPaymentOptions = PrefPaymentReplaceOptions;
+export type CreatePrefClientOptions = PrefClientInsertOptions;
+export type ReplacePrefClientOptions = PrefClientReplaceOptions;
+export type CreatePrefEmployeeOptions = PrefEmployeeInsertOptions;
+export type ReplacePrefEmployeeOptions = PrefEmployeeReplaceOptions;
+export type CreatePrefCompanyOptions = PrefCompanyInsertOptions;
+export type ReplacePrefCompanyOptions = PrefCompanyReplaceOptions;
+export type CreatePrefVisibilityOptions = PrefVisibilityInsertOptions;
+export type ReplacePrefVisibilityOptions = PrefVisibilityReplaceOptions;
+export type CreatePrefLanguageOptions = PrefLanguageInsertOptions;
+export type ReplacePrefLanguageOptions = PrefLanguageReplaceOptions;
+export type CreatePrefNotifOptions = PrefNotifInsertOptions;
+export type ReplacePrefNotifOptions = PrefNotifReplaceOptions;
+export type CreatePrefEmailOptions = PrefEmailInsertOptions;
+export type ReplacePrefEmailOptions = PrefEmailReplaceOptions;
+export type CreatePrefTutorialOptions = PrefTutorialInsertOptions;
+export type ReplacePrefTutorialOptions = PrefTutorialReplaceOptions;
 export type EnsurePrefLanguageOptions = {
     owner_id: string;
     language: string;
@@ -7,6 +43,24 @@ export type EnsurePrefLanguageOptions = {
     speech_to_text_source_language?: string;
 };
 export interface PreferencesFXOperator {
+    createPrefPayment(opts: CreatePrefPaymentOptions): Promise<PrefPayment>;
+    replacePrefPayment(opts: ReplacePrefPaymentOptions): Promise<PrefPayment>;
+    createPrefClient(opts: CreatePrefClientOptions): Promise<PrefClient>;
+    replacePrefClient(opts: ReplacePrefClientOptions): Promise<PrefClient>;
+    createPrefEmployee(opts: CreatePrefEmployeeOptions): Promise<PrefEmployee>;
+    replacePrefEmployee(opts: ReplacePrefEmployeeOptions): Promise<PrefEmployee>;
+    createPrefCompany(opts: CreatePrefCompanyOptions): Promise<PrefCompany>;
+    replacePrefCompany(opts: ReplacePrefCompanyOptions): Promise<PrefCompany>;
+    createPrefVisibility(opts: CreatePrefVisibilityOptions): Promise<PrefVisibility>;
+    replacePrefVisibility(opts: ReplacePrefVisibilityOptions): Promise<PrefVisibility>;
+    createPrefLanguage(opts: CreatePrefLanguageOptions): Promise<PrefLanguage>;
+    replacePrefLanguage(opts: ReplacePrefLanguageOptions): Promise<PrefLanguage>;
+    createPrefNotif(opts: CreatePrefNotifOptions): Promise<PrefNotif>;
+    replacePrefNotif(opts: ReplacePrefNotifOptions): Promise<PrefNotif>;
+    createPrefEmail(opts: CreatePrefEmailOptions): Promise<PrefEmail>;
+    replacePrefEmail(opts: ReplacePrefEmailOptions): Promise<PrefEmail>;
+    createPrefTutorial(opts: CreatePrefTutorialOptions): Promise<PrefTutorial>;
+    replacePrefTutorial(opts: ReplacePrefTutorialOptions): Promise<PrefTutorial>;
     ensurePrefLanguage(opts: EnsurePrefLanguageOptions): Promise<OperationResult>;
 }
 export type PreferencesFXOptions = {
@@ -15,6 +69,34 @@ export type PreferencesFXOptions = {
 export declare class PreferencesFX implements PreferencesFXOperator {
     private preferences;
     constructor(opts: PreferencesFXOptions);
+    createPrefPayment(opts: CreatePrefPaymentOptions): Promise<PrefPayment>;
+    replacePrefPayment(opts: ReplacePrefPaymentOptions): Promise<PrefPayment>;
+    createPrefClient(opts: CreatePrefClientOptions): Promise<PrefClient>;
+    replacePrefClient(opts: ReplacePrefClientOptions): Promise<PrefClient>;
+    createPrefEmployee(opts: CreatePrefEmployeeOptions): Promise<PrefEmployee>;
+    replacePrefEmployee(opts: ReplacePrefEmployeeOptions): Promise<PrefEmployee>;
+    createPrefCompany(opts: CreatePrefCompanyOptions): Promise<PrefCompany>;
+    replacePrefCompany(opts: ReplacePrefCompanyOptions): Promise<PrefCompany>;
+    createPrefVisibility(opts: CreatePrefVisibilityOptions): Promise<PrefVisibility>;
+    replacePrefVisibility(opts: ReplacePrefVisibilityOptions): Promise<PrefVisibility>;
+    createPrefLanguage(opts: CreatePrefLanguageOptions): Promise<PrefLanguage>;
+    replacePrefLanguage(opts: ReplacePrefLanguageOptions): Promise<PrefLanguage>;
+    createPrefNotif(opts: CreatePrefNotifOptions): Promise<PrefNotif>;
+    replacePrefNotif(opts: ReplacePrefNotifOptions): Promise<PrefNotif>;
+    createPrefEmail(opts: CreatePrefEmailOptions): Promise<PrefEmail>;
+    replacePrefEmail(opts: ReplacePrefEmailOptions): Promise<PrefEmail>;
+    createPrefTutorial(opts: CreatePrefTutorialOptions): Promise<PrefTutorial>;
+    replacePrefTutorial(opts: ReplacePrefTutorialOptions): Promise<PrefTutorial>;
     ensurePrefLanguage(opts: EnsurePrefLanguageOptions): Promise<OperationResult>;
+    private findPrefPayment;
+    private findPrefClient;
+    private findPrefEmployee;
+    private findPrefCompany;
+    private findPrefVisibility;
+    private findPrefLanguage;
+    private findPrefNotif;
+    private findPrefEmail;
+    private findPrefTutorial;
 }
 export declare function newPreferencesFX(opts: PreferencesFXOptions): PreferencesFX;
+export {};