@fabriktor/fx 0.0.120 → 0.0.122

package/dist/src/billable/billable.d.ts

@@ -88,7 +88,9 @@ export type CreateVendorInvoiceOptions = VendorInvoiceInsertOptions & MultiCreat
     owner_id: string;
     allow_duplicate?: boolean;
 };
-export type ReplaceVendorInvoiceOptions = VendorInvoiceReplaceOptions;
+export type ReplaceVendorInvoiceOptions = VendorInvoiceReplaceOptions & {
+    allow_duplicate?: boolean;
+};
 export type SearchVendorInvoicesOptions = OwnerSearchOptions & Partial<Pick<VendorInvoice, "is_archived">>;
 export type SearchVendorInvoicesPage = SearchPage<VendorInvoice>;
 export type CreateWarehouseOptions = WarehouseInsertOptions & MultiCreateCheckpoint;

package/dist/src/billable/billable.js

@@ -380,8 +380,17 @@ export class BillableFX {
         return await this.findVendorInvoice(id);
     }
     async replaceVendorInvoice(opts) {
-        await this.billable.replaceOneVendorInvoice(opts);
-        return await this.findVendorInvoice(opts.id);
+        const { allow_duplicate, ...request } = opts;
+        if (request.in.number !== undefined) {
+            const current = await this.findVendorInvoice(request.id);
+            const number = request.in.number.trim();
+            if (!allow_duplicate && number !== current.number) {
+                await this.checkVendorInvoiceNumber(current.owner_id, number, current.id);
+            }
+            request.in = { ...request.in, number };
+        }
+        await this.billable.replaceOneVendorInvoice(request);
+        return await this.findVendorInvoice(request.id);
     }
     async searchVendorInvoices(opts) {
         return await runOwnerSearch({
@@ -479,14 +488,14 @@ export class BillableFX {
         const id = requiredOperationID(out, msgCreatedBillIDMissing);
         return await this.findBill(id);
     }
-    async checkVendorInvoiceNumber(owner_id, number) {
+    async checkVendorInvoiceNumber(owner_id, number, excluding_id) {
         await runPreActionCheck({
             reason: BillablePreActionReason.VendorInvoiceNumberExists,
             allowed: async () => {
                 const out = await this.billable.queryVendorInvoices({
                     query: withOwnerQuery(owner_id, queryParams({ number })),
                 });
-                return (out.value?.length ?? 0) === 0;
+                return !(out.value ?? []).some((record) => record.id !== excluding_id);
             },
         });
     }

package/dist/src/timesheets/access.d.ts

@@ -13,9 +13,16 @@ export type QueryTimesheetSyncDestinationsOptions = {
     source: WeekSheet;
     signal?: AbortSignal;
 };
+export type QueryTimesheetSyncSourcesOptions = Pick<TimesheetsReadOptions, "context" | "owner_ids" | "period_indexes" | "signal">;
+export type TimesheetSyncTarget = {
+    owner_id: string;
+    week_sheet?: WeekSheet;
+};
 type TimesheetRecord = WeekSheet | Summary;
 export declare function timesheetCanReadResource(context: TimesheetsActor): boolean;
 export declare function timesheetCanCreateWeek(context: TimesheetsActor): boolean;
+export declare function timesheetCanManageSync(context: TimesheetsActor): boolean;
+export declare function timesheetCanSyncRecord(context: TimesheetsActor, record: WeekSheet | null | undefined): boolean;
 export declare function timesheetCanReadRecord(context: TimesheetsActor, record: TimesheetRecord | null | undefined): boolean;
 export declare function timesheetCanWriteRecord(context: TimesheetsActor, record: TimesheetRecord | null | undefined): boolean;
 export declare function timesheetCanDeleteRecord(context: TimesheetsActor, record: TimesheetRecord | null | undefined): boolean;

package/dist/src/timesheets/access.js

@@ -1,13 +1,20 @@
-import { PunchStatusWorking, UserTypeEmployee, } from "@fabriktor/schema";
+import { PunchStatusWorking, UserTypeEmployee, UserTypeEmployer, } from "@fabriktor/schema";
 import { employmentActivityOwnerIDs, employmentCanRead, employmentEmployeeIDs, employmentEmployerIDs, employmentManagesRecord, employmentOwnsRecord, } from "../contacts/scope.js";
 import { restrictOwnerIDs } from "../core/scope.js";
-import { timesheetCanApprove, timesheetCanSync, timesheetHasWorkingPunches, timesheetIsMutable, } from "./workspace.js";
+import { timesheetCanApprove, timesheetCanSync, timesheetCanSyncSource, timesheetHasWorkingPunches, timesheetIsMutable, } from "./workspace.js";
 export function timesheetCanReadResource(context) {
     return employmentCanRead(context);
 }
 export function timesheetCanCreateWeek(context) {
     return timesheetCanReadResource(context) && context.active_mode === UserTypeEmployee;
 }
+export function timesheetCanManageSync(context) {
+    return timesheetCanReadResource(context) && context.active_mode === UserTypeEmployer;
+}
+export function timesheetCanSyncRecord(context, record) {
+    return record != null && timesheetCanManageSync(context) &&
+        employmentManagesRecord(context, record) && timesheetCanSyncSource(record);
+}
 export function timesheetCanReadRecord(context, record) {
     return timesheetCanReadResource(context) && record != null && (employmentOwnsRecord(context, record) || employmentManagesRecord(context, record));
 }
@@ -30,7 +37,7 @@ export function timesheetCanEditDay(context, record, week_day) {
         day.punches.every((punch) => punch.punch_status !== PunchStatusWorking);
 }
 export function timesheetCanSyncDestination(context, source, destination) {
-    return timesheetCanApproveRecord(context, source) &&
+    return timesheetCanSyncRecord(context, source) &&
         timesheetCanWriteRecord(context, destination) && timesheetCanSync(source, destination);
 }
 export function timesheetEmployeeScopeIDs(context) {

package/dist/src/timesheets/timesheets.d.ts

@@ -1,7 +1,7 @@
 import { type Date as SchemaDate, type OperationResult, type Summary, type WeekSheet } from "@fabriktor/schema";
 import type { BillableOperator, TimesheetsOperator } from "@fabriktor/client";
 import type { ContactsFXOperator } from "../contacts/contacts.js";
-import { type LoadTimesheetsReadContextOptions, type QueryTimesheetSyncDestinationsOptions, type TimesheetsReadContext, type TimesheetsReadOptions } from "./access.js";
+import { type LoadTimesheetsReadContextOptions, type QueryTimesheetSyncDestinationsOptions, type QueryTimesheetSyncSourcesOptions, type TimesheetsReadContext, type TimesheetsReadOptions, type TimesheetSyncTarget } from "./access.js";
 import { TimesheetsWorkspace } from "./workspace.js";
 type PunchPayload = Parameters<TimesheetsOperator["punch"]>[0];
 type WeekSheetReplaceOptions = Parameters<TimesheetsOperator["replaceOneWeekSheet"]>[0];
@@ -57,7 +57,9 @@ export type PunchControls = {
 };
 export type SyncWeekOptions = {
     from: WeekSheet;
-    to: WeekSheet[];
+    to?: WeekSheet[];
+    to_owner_ids?: string[];
+    actor?: LoadTimesheetsReadContextOptions;
 };
 export type SyncDaysOptions = SyncWeekOptions & {
     days: number[];
@@ -72,6 +74,8 @@ export interface TimesheetsFXOperator {
     queryReadableWeekSheets(opts: TimesheetsReadOptions): Promise<WeekSheet[]>;
     queryReadableSummaries(opts: TimesheetsReadOptions): Promise<Summary[]>;
     querySyncDestinations(opts: QueryTimesheetSyncDestinationsOptions): Promise<WeekSheet[]>;
+    querySyncSources(opts: QueryTimesheetSyncSourcesOptions): Promise<WeekSheet[]>;
+    querySyncTargets(opts: QueryTimesheetSyncDestinationsOptions): Promise<TimesheetSyncTarget[]>;
     replaceWeekSheet(opts: ReplaceWeekSheetOptions): Promise<WeekSheet>;
     replaceSummary(opts: ReplaceSummaryOptions): Promise<Summary>;
     punchControls(opts: PunchControlsOptions): PunchControls;
@@ -96,6 +100,8 @@ export declare class TimesheetsFX implements TimesheetsFXOperator {
     queryReadableWeekSheets(opts: TimesheetsReadOptions): Promise<WeekSheet[]>;
     queryReadableSummaries(opts: TimesheetsReadOptions): Promise<Summary[]>;
     querySyncDestinations(opts: QueryTimesheetSyncDestinationsOptions): Promise<WeekSheet[]>;
+    querySyncSources(opts: QueryTimesheetSyncSourcesOptions): Promise<WeekSheet[]>;
+    querySyncTargets(opts: QueryTimesheetSyncDestinationsOptions): Promise<TimesheetSyncTarget[]>;
     replaceWeekSheet(opts: ReplaceWeekSheetOptions): Promise<WeekSheet>;
     replaceSummary(opts: ReplaceSummaryOptions): Promise<Summary>;
     punchControls(opts: PunchControlsOptions): PunchControls;

package/dist/src/timesheets/timesheets.js

@@ -9,8 +9,8 @@ import { errRequired, errResolveFailed, errValidation, } from "../core/err.js";
 import { normalizeIDs } from "../core/id.js";
 import { loadEmploymentReadContext } from "../contacts/scope.js";
 import { PreActionBlocked } from "../core/pre-action.js";
-import { timesheetCanApproveRecord, timesheetCanSyncDestination, timesheetReadFilters, } from "./access.js";
-import { TimesheetsWorkspace, TimesheetsBlock, timesheetCanApprove, timesheetCanSync, timesheetIsMutable, } from "./workspace.js";
+import { timesheetCanSyncRecord, timesheetCanSyncDestination, timesheetEmployeeScopeIDs, timesheetReadFilters, } from "./access.js";
+import { TimesheetsWorkspace, TimesheetsBlock, timesheetCanApprove, timesheetCanSync, timesheetCanSyncSource, timesheetIsMutable, } from "./workspace.js";
 const allWeekDays = [0, 1, 2, 3, 4, 5, 6];
 const minuteStep = 15;
 const msgPunchInProgress = "A punch action is already in progress.";
@@ -55,7 +55,7 @@ export class TimesheetsFX {
         const source = await this.workspace.week(opts.source.id, opts.signal);
         if (source.updated_at !== opts.source.updated_at)
             throw new PreActionBlocked(TimesheetsBlock.Changed);
-        if (!timesheetCanApproveRecord(opts.context, source))
+        if (!timesheetCanSyncRecord(opts.context, source))
             throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
         const weeks = await this.queryReadableWeekSheets({
             context: opts.context,
@@ -66,6 +66,41 @@ export class TimesheetsFX {
         });
         return weeks.filter((week) => timesheetCanSyncDestination(opts.context, source, week));
     }
+    async querySyncSources(opts) {
+        // Full weeks are needed for eligibility; never use cleaned day/punch results.
+        const weeks = await this.queryReadableWeekSheets({
+            context: opts.context,
+            owner_ids: opts.owner_ids,
+            period_indexes: opts.period_indexes,
+            signal: opts.signal,
+        });
+        return weeks.filter((week) => timesheetCanSyncRecord(opts.context, week));
+    }
+    async querySyncTargets(opts) {
+        const source = await this.workspace.week(opts.source.id, opts.signal);
+        if (source.updated_at !== opts.source.updated_at)
+            throw new PreActionBlocked(TimesheetsBlock.Changed);
+        if (!timesheetCanSyncRecord(opts.context, source))
+            throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
+        // Include locked records: hiding them would mistake them for missing weeks.
+        const weeks = await this.queryReadableWeekSheets({
+            context: opts.context,
+            employer_ids: [source.employer_id],
+            period_indexes: [source.period_index],
+            signal: opts.signal,
+        });
+        const targets = [];
+        for (const owner_id of timesheetEmployeeScopeIDs(opts.context)) {
+            if (owner_id === source.owner_id)
+                continue;
+            const matches = weeks.filter((week) => week.owner_id === owner_id);
+            if (matches.length === 0)
+                targets.push({ owner_id });
+            else if (matches.length === 1 && timesheetCanSyncDestination(opts.context, source, matches[0]))
+                targets.push({ owner_id, week_sheet: matches[0] });
+        }
+        return targets;
+    }
     async replaceWeekSheet(opts) {
         await this.timesheets.replaceOneWeekSheet(opts);
         return await this.findWeekSheet(opts.id);
@@ -212,8 +247,7 @@ export class TimesheetsFX {
     }
     async syncWeek(opts) {
         await this.syncSheets({
-            from: opts.from,
-            to: opts.to,
+            ...opts,
             days: [...allWeekDays],
         });
     }
@@ -226,8 +260,7 @@ export class TimesheetsFX {
             });
         }
         await this.syncSheets({
-            from: opts.from,
-            to: opts.to,
+            ...opts,
             days,
         });
     }
@@ -308,18 +341,36 @@ export class TimesheetsFX {
         const source = await this.findWeekSheet(opts.from.id);
         if (source.updated_at !== opts.from.updated_at)
             throw new PreActionBlocked(TimesheetsBlock.Changed);
-        if (!timesheetCanApprove(source))
+        if (!timesheetCanSyncSource(source))
             throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
         opts = { ...opts, from: source };
         const from_id = requiredID(opts.from.id, "from", msgWeekSheetIDRequired);
-        if (opts.to.length === 0) {
+        const owner_ids = normalizeIDs(opts.to_owner_ids ?? []);
+        if (!opts.to?.length && owner_ids.length === 0) {
             throw errRequired({
                 field: "to",
                 msg: msgDestinationWeekSheetsRequired,
             });
         }
+        if (owner_ids.length > 0) {
+            if (!opts.actor)
+                throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
+            const context = await this.loadReadContext(opts.actor);
+            const targets = await this.querySyncTargets({ context, source });
+            if (owner_ids.some((id) => !targets.some((target) => target.owner_id === id)))
+                throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
+            // Refetch full records immediately before submission. The service checks
+            // again inside its transaction and creates missing destinations there.
+            for (const target of targets) {
+                if (!owner_ids.includes(target.owner_id) || !target.week_sheet)
+                    continue;
+                const fresh = await this.findWeekSheet(target.week_sheet.id);
+                if (!timesheetCanSync(source, fresh))
+                    throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
+            }
+        }
         const to_ids = [];
-        for (const expected of opts.to) {
+        for (const expected of opts.to ?? []) {
             const week_sheet = await this.findWeekSheet(expected.id);
             if (week_sheet.updated_at !== expected.updated_at)
                 throw new PreActionBlocked(TimesheetsBlock.Changed);
@@ -337,6 +388,7 @@ export class TimesheetsFX {
         const input = {
             from_id,
             to_ids: normalizeIDs(to_ids),
+            to_owner_ids: owner_ids,
             days: normalizeDays(opts.days),
         };
         await this.timesheets.sync(input);

package/dist/src/timesheets/workspace.d.ts

@@ -50,6 +50,7 @@ export declare function timesheetPunches(sheet: WeekSheet): Punch[];
 export declare function timesheetHasWorkingPunches(sheet: WeekSheet): boolean;
 export declare function timesheetIsMutable(sheet: WeekSheet): boolean;
 export declare function timesheetCanApprove(sheet: WeekSheet): boolean;
+export declare function timesheetCanSyncSource(sheet: WeekSheet): boolean;
 export declare function timesheetCanSync(source: WeekSheet, destination: WeekSheet): boolean;
 export declare function timesheetStateKey(state: TimesheetPunchState): string;
 export declare function timesheetWeekDay(date: InDate): number;

package/dist/src/timesheets/workspace.js

@@ -32,12 +32,18 @@ export function timesheetCanApprove(sheet) {
         punches.length > 0 &&
         punches.every((p) => p.punch_status === PunchStatusPending));
 }
+export function timesheetCanSyncSource(sheet) {
+    const punches = timesheetPunches(sheet);
+    return punches.length > 0 && punches.every((punch) => punch.punch_status === PunchStatusPending || punch.punch_status === PunchStatusApproved);
+}
 export function timesheetCanSync(source, destination) {
-    return timesheetCanApprove(source) && timesheetIsMutable(destination) &&
-        !timesheetHasWorkingPunches(destination) &&
+    return timesheetCanSyncSource(source) && !destination.is_archived &&
+        timesheetPunches(destination).every((punch) => punch.punch_status === PunchStatusPending) &&
         destination.employer_id === source.employer_id &&
         destination.id !== source.id &&
         destination.period_index === source.period_index &&
+        destination.period === source.period &&
+        destination.period_year === source.period_year &&
         destination.timezone === source.timezone;
 }
 export function timesheetStateKey(state) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.120",
+  "version": "0.0.122",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,8 +17,8 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "0.0.88",
+    "@fabriktor/client": "0.0.90",
     "@fabriktor/fx": "0.0.94",
-    "@fabriktor/schema": "0.0.64"
+    "@fabriktor/schema": "0.0.65"
   }
 }