@fabriktor/fx 0.0.149 → 0.0.150

package/dist/src/chat/data.js

@@ -14,19 +14,24 @@ export function newChatData(type, payload) {
         type,
         payload,
     };
-    if (!validChatData(data))
-        throw errValidation({ msg: msgChatData });
-    return structuredClone(data);
+    // JSON snapshots also accept reactive UI objects without structuredClone's
+    // Proxy failure. Validation and size limits are shared with sending.
+    return JSON.parse(serializeChatData(data));
 }
 export function encodeChatContent(text, data) {
     if (!data)
         return text;
-    if (!text.trim() || text.includes(chatDataMarker) || !validChatData(data))
+    if (!text.trim() || text.includes(chatDataMarker))
+        throw errValidation({ msg: msgChatData });
+    return text.trim() + chatDataMarker + serializeChatData(data);
+}
+function serializeChatData(data) {
+    if (!validChatData(data))
         throw errValidation({ msg: msgChatData });
     const value = JSON.stringify(data);
     if (new TextEncoder().encode(value).length > chatDataMaximumBytes)
         throw errValidation({ msg: msgChatData });
-    return text.trim() + chatDataMarker + value;
+    return value;
 }
 export function decodeChatContent(value) {
     const boundary = value.indexOf(chatDataMarker);

package/dist/src/chat/forms.d.ts

@@ -1,9 +1,16 @@
 import type { User } from "@fabriktor/schema";
 import type { EmploymentActor } from "../contacts/scope.js";
+import { type ChatData, type ChatJSON } from "./data.js";
 export type ChatFormRecipient = Pick<User, "id" | "account_identity">;
 export type ChatFormPolicy = {
     readonly sender_modes: readonly User["active_mode"][];
     readonly recipient_modes: readonly User["active_mode"][];
     readonly allow_group: boolean;
 };
+export type ChatFormContextDefinition<T extends ChatJSON> = {
+    readonly version: number;
+    readonly read: (value: ChatJSON | undefined) => T | undefined;
+};
+export declare function newChatFormData<T extends ChatJSON>(type: string, payload: ChatData["payload"], definition: ChatFormContextDefinition<T>, context: T): ChatData;
+export declare function readChatFormContext<T extends ChatJSON>(data: ChatData, definition: ChatFormContextDefinition<T>): T;
 export declare function canSendChatForm(policy: ChatFormPolicy, actor: EmploymentActor, recipients: readonly ChatFormRecipient[]): boolean;

package/dist/src/chat/forms.js

@@ -1,5 +1,29 @@
+import { errValidation } from "../core/err.js";
 import { normalizeIDs, resolvedID } from "../core/id.js";
+import { newChatData } from "./data.js";
 import { isFabriktorUser, isOtherUserID, userSupportsMode, } from "../users/users.js";
+const msgFormContext = "The form details are missing or unsupported. Ask the sender to send a new form.";
+export function newChatFormData(type, payload, definition, context) {
+    const value = definition.read(context);
+    if (value === undefined)
+        throw errValidation({ msg: msgFormContext });
+    return newChatData(type, {
+        ...payload,
+        form_context: { version: definition.version, data: value },
+    });
+}
+export function readChatFormContext(data, definition) {
+    const context = data.payload.form_context;
+    if (context &&
+        typeof context === "object" &&
+        !Array.isArray(context) &&
+        context.version === definition.version) {
+        const value = definition.read(context.data);
+        if (value !== undefined)
+            return value;
+    }
+    throw errValidation({ msg: msgFormContext });
+}
 // Recipients are all other members of the conversation, resolved before use.
 // Sender modes apply now; recipient modes describe what their identity supports.
 // Do not depend on the recipient's current mode, which Public() omits.

package/dist/src/jobs/jobs.js

@@ -12,6 +12,7 @@ import { runPreActionCheck } from "../core/pre-action.js";
 import { runOwnerSearch, runSearch, withOwnerQuery, } from "../core/search.js";
 const msgJobIDRequired = "Job ID is required.";
 const msgLocationIDRequired = "Location ID is required.";
+const msgLocationClientRequired = "Choose a client for this location.";
 const msgOwnerIDRequired = "Owner ID is required.";
 const msgMemberIDRequired = "Member ID is required.";
 const msgJobLocationMismatch = "Job location does not match the provided parent location.";
@@ -59,9 +60,11 @@ export class JobsFX {
         this.now = opts.now ?? (() => new globalThis.Date());
     }
     async createLocation(opts) {
+        const client_id = requiredID(opts.in.client_id, "client_id", msgLocationClientRequired);
         const out = await this.jobs.insertOneLocation({
             in: {
                 ...opts.in,
+                client_id,
                 is_archived: false,
                 current_members: normalizeIDs(opts.in.current_members),
             },
@@ -72,8 +75,12 @@ export class JobsFX {
     async updateLocation(opts) {
         const owner_id = requiredID(opts.owner_id, "owner_id", msgOwnerIDRequired);
         const id = requiredID(opts.location.id, "location", msgLocationIDRequired);
+        const client_id = requiredID(opts.in.client_id === undefined
+            ? opts.location.client_id
+            : opts.in.client_id, "client_id", msgLocationClientRequired);
         const input = {
             ...opts.in,
+            client_id,
             ...locationAddressInput(opts.location),
         };
         if (opts.in.current_members !== undefined) {

package/dist/src/routes/availability.d.ts

@@ -2,7 +2,7 @@ import type { JobsOperator, RoutesOperator, UsersOperator } from "@fabriktor/cli
 import { type ClientAvailability, type InClientAvailability, type Location, type PrefCompany, type User } from "@fabriktor/schema";
 import type { PreferencesFXOperator } from "../preferences/preferences.js";
 import { type ChatData } from "../chat/data.js";
-import { type ChatFormRecipient } from "../chat/forms.js";
+import { type ChatFormContextDefinition, type ChatFormRecipient } from "../chat/forms.js";
 import { type RoutesActor } from "./workspace.js";
 export declare const clientAvailabilityMinimumWindows = 3;
 export declare const availabilityRequestPolicy: {
@@ -21,23 +21,35 @@ export type AvailabilityContext = {
     location: Location;
     employer: User;
     client: User;
-    company: PrefCompany;
+    working_hours?: AvailabilityWorkingHours;
     timezone: string;
 };
 export type AvailabilityReaders = {
     jobs: Pick<JobsOperator, "findOneLocation">;
     users: Pick<UsersOperator, "findOneUser">;
-    preferences: Pick<PreferencesFXOperator, "getPrefCompany">;
+};
+export type AvailabilityWorkingHours = Pick<PrefCompany, "work_day_start_hour" | "work_day_end_hour">;
+export type AvailabilityFormContext = {
+    working_hours: AvailabilityWorkingHours;
+    timezone: Location["address_timezone"];
+};
+export declare const availabilityFormContextDefinition: ChatFormContextDefinition<AvailabilityFormContext>;
+export type AvailabilityContextOptions = {
+    request?: ChatData;
+    signal?: AbortSignal;
 };
 export declare function availabilityReference(data: ChatData): AvailabilityReference | undefined;
 export declare function availabilityRequest(location: Location, actor: RoutesActor): ChatData;
 export declare function canSendAvailabilityRequest(data: ChatData, actor: RoutesActor, recipients: readonly ChatFormRecipient[]): boolean;
+export declare function loadAvailabilityRequestContext(readers: AvailabilityReaders & {
+    preferences: Pick<PreferencesFXOperator, "getPrefCompany">;
+}, actor: RoutesActor, data: ChatData): Promise<AvailabilityFormContext>;
 export declare function availabilitySubmission(reference: AvailabilityReference, request_id: string, ids: readonly string[]): ChatData;
-export declare function loadAvailabilityContext(readers: AvailabilityReaders, actor: RoutesActor, reference: AvailabilityReference, signal?: AbortSignal): Promise<AvailabilityContext>;
+export declare function loadAvailabilityContext(readers: AvailabilityReaders, actor: RoutesActor, reference: AvailabilityReference, { request, signal }?: AvailabilityContextOptions): Promise<AvailabilityContext>;
 export declare function validateAvailabilityWindows(inputs: readonly InClientAvailability[], context: AvailabilityContext, minimum?: number): void;
 export declare function loadAvailabilitySelection(readers: AvailabilityReaders & {
     routes: Pick<RoutesOperator, "findOneClientAvailability">;
-}, actor: RoutesActor, reference: AvailabilityReference, ids: readonly string[], signal?: AbortSignal): Promise<{
+}, actor: RoutesActor, reference: AvailabilityReference, ids: readonly string[], options?: AvailabilityContextOptions): Promise<{
     context: AvailabilityContext;
     windows: ClientAvailability[];
 }>;

package/dist/src/routes/availability.js

@@ -5,7 +5,7 @@ import { hoursPerDay, minutesOfDay, minutesPerHour, sameCalendarDay, } from "../
 import { errValidation } from "../core/err.js";
 import { normalizeIDs, resolvedID } from "../core/id.js";
 import { newChatData } from "../chat/data.js";
-import { canSendChatForm, } from "../chat/forms.js";
+import { canSendChatForm, readChatFormContext, } from "../chat/forms.js";
 import { routeCanPlan } from "./workspace.js";
 import { validateClientAvailabilityInput } from "./validation.js";
 export const clientAvailabilityMinimumWindows = 3;
@@ -18,10 +18,35 @@ export const RoutesChatDataType = {
     AvailabilityRequest: "routes.availability.request",
     AvailabilitySubmitted: "routes.availability.submitted",
 };
+export const availabilityFormContextDefinition = {
+    version: 1,
+    read: (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const { working_hours, timezone } = value;
+        if (!working_hours ||
+            typeof working_hours !== "object" ||
+            Array.isArray(working_hours) ||
+            typeof timezone !== "string" ||
+            !timezone.trim())
+            return;
+        const { work_day_start_hour: start, work_day_end_hour: end } = working_hours;
+        if (typeof start !== "number" ||
+            typeof end !== "number" ||
+            ![start, end].every((hour) => Number.isInteger(hour) && hour >= 0 && hour < hoursPerDay) ||
+            start >= end)
+            return;
+        return {
+            timezone,
+            working_hours: { work_day_start_hour: start, work_day_end_hour: end },
+        };
+    },
+};
 const msgAvailabilityAccess = "This availability does not match the client and employer of the location.";
 const msgAvailabilityTimezone = "The location needs a valid saved address timezone.";
+const msgAvailabilityTimezoneChanged = "The location timezone has changed. Ask the sender to send a new form.";
 const msgAvailabilityHours = "The employer's working hours must form a valid same-day window.";
-const msgAvailabilityWindows = "Provide enough distinct, non-overlapping availability windows within the employer's working hours.";
+const msgAvailabilityWindows = "Provide enough distinct, non-overlapping availability windows and respect the hours supplied with the request.";
 const msgAvailabilityClient = "Visit times can only be requested from clients with a Fabriktor account. Arrange external contacts’ visit times directly.";
 const msgAvailabilityData = "The availability request is invalid.";
 export function availabilityReference(data) {
@@ -69,6 +94,30 @@ export function canSendAvailabilityRequest(data, actor, recipients) {
         canSendChatForm(availabilityRequestPolicy, actor, recipients) &&
         reference.client_id === recipients[0].id);
 }
+// Registry pre-action: only the employer preparing the request reads their
+// preferences. Transfer the two hours, never the complete preferences record.
+export async function loadAvailabilityRequestContext(readers, actor, data) {
+    const reference = availabilityReference(data);
+    if (data.type !== RoutesChatDataType.AvailabilityRequest ||
+        !reference ||
+        !routeCanPlan(actor) ||
+        reference.employer_id !== actor.owner_id)
+        throw errValidation({ msg: msgAvailabilityAccess });
+    const [context, company] = await Promise.all([
+        loadAvailabilityContext(readers, actor, reference),
+        readers.preferences.getPrefCompany({ owner_id: actor.owner_id }),
+    ]);
+    const supplied = availabilityFormContextDefinition.read({
+        timezone: context.timezone,
+        working_hours: {
+            work_day_start_hour: company.work_day_start_hour,
+            work_day_end_hour: company.work_day_end_hour,
+        },
+    });
+    if (!supplied)
+        throw errValidation({ msg: msgAvailabilityHours });
+    return supplied;
+}
 export function availabilitySubmission(reference, request_id, ids) {
     const data = newChatData(RoutesChatDataType.AvailabilitySubmitted, {
         ...reference,
@@ -79,7 +128,19 @@ export function availabilitySubmission(reference, request_id, ids) {
         throw errValidation({ msg: msgAvailabilityData });
     return data;
 }
-export async function loadAvailabilityContext(readers, actor, reference, signal) {
+export async function loadAvailabilityContext(readers, actor, reference, { request, signal } = {}) {
+    const supplied = request
+        ? readChatFormContext(request, availabilityFormContextDefinition)
+        : undefined;
+    if (request) {
+        const requestReference = availabilityReference(request);
+        if (request.type !== RoutesChatDataType.AvailabilityRequest ||
+            !requestReference ||
+            requestReference.employer_id !== reference.employer_id ||
+            requestReference.client_id !== reference.client_id ||
+            requestReference.location_id !== reference.location_id)
+            throw errValidation({ msg: msgAvailabilityAccess });
+    }
     const location = (await readers.jobs.findOneLocation({ id: reference.location_id, signal })).value;
     if (!location ||
         location.id !== reference.location_id ||
@@ -90,10 +151,9 @@ export async function loadAvailabilityContext(readers, actor, reference, signal)
             ? actor.owner_id !== reference.client_id
             : !routeCanPlan(actor) || actor.owner_id !== reference.employer_id))
         throw errValidation({ msg: msgAvailabilityAccess });
-    const [result, clientResult, company] = await Promise.all([
+    const [result, clientResult] = await Promise.all([
         readers.users.findOneUser({ id: reference.employer_id, signal }),
         readers.users.findOneUser({ id: reference.client_id, signal }),
-        readers.preferences.getPrefCompany({ owner_id: reference.employer_id }),
     ]);
     const employer = result.value;
     if (!employer ||
@@ -108,11 +168,15 @@ export async function loadAvailabilityContext(readers, actor, reference, signal)
     const timezone = addressTimezone(location);
     if (!timezone)
         throw errValidation({ msg: msgAvailabilityTimezone });
-    const { work_day_start_hour: start, work_day_end_hour: end } = company;
-    if (![start, end].every((hour) => Number.isInteger(hour) && hour >= 0 && hour < hoursPerDay) ||
-        start >= end)
-        throw errValidation({ msg: msgAvailabilityHours });
-    return { location, employer, client, company, timezone };
+    if (supplied && supplied.timezone !== timezone)
+        throw errValidation({ msg: msgAvailabilityTimezoneChanged });
+    return {
+        location,
+        employer,
+        client,
+        working_hours: supplied?.working_hours,
+        timezone,
+    };
 }
 export function validateAvailabilityWindows(inputs, context, minimum = clientAvailabilityMinimumWindows) {
     if (inputs.length < minimum)
@@ -122,10 +186,11 @@ export function validateAvailabilityWindows(inputs, context, minimum = clientAva
         if (input.employer_id !== context.employer.id ||
             input.location_id !== context.location.id ||
             input.timezone !== context.timezone ||
-            minutesOfDay(input.from) <
-                context.company.work_day_start_hour * minutesPerHour ||
-            minutesOfDay(input.to) >
-                context.company.work_day_end_hour * minutesPerHour ||
+            (context.working_hours &&
+                (minutesOfDay(input.from) <
+                    context.working_hours.work_day_start_hour * minutesPerHour ||
+                    minutesOfDay(input.to) >
+                        context.working_hours.work_day_end_hour * minutesPerHour)) ||
             inputs
                 .slice(0, index)
                 .some((other) => sameCalendarDay(input.from, other.from) &&
@@ -136,13 +201,16 @@ export function validateAvailabilityWindows(inputs, context, minimum = clientAva
 }
 // A chat response contains references, never authority or an appointment confirmation.
 // Reload each chosen record before preparing the response, including after a resumed batch.
-export async function loadAvailabilitySelection(readers, actor, reference, ids, signal) {
+export async function loadAvailabilitySelection(readers, actor, reference, ids, options = {}) {
     if (ids.length < clientAvailabilityMinimumWindows ||
         normalizeIDs(ids).length !== ids.length)
         throw errValidation({ msg: msgAvailabilityData });
-    const context = await loadAvailabilityContext(readers, actor, reference, signal);
+    const context = await loadAvailabilityContext(readers, actor, reference, options);
     const windows = await Promise.all(ids.map(async (id) => {
-        const window = (await readers.routes.findOneClientAvailability({ id, signal })).value;
+        const window = (await readers.routes.findOneClientAvailability({
+            id,
+            signal: options.signal,
+        })).value;
         if (!window ||
             window.id !== id ||
             window.owner_id !== reference.client_id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.149",
+  "version": "0.0.150",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {