@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/data/labels.js

@@ -0,0 +1,179 @@
+/**
+ * Labels for related records, and the searches the relation selectors run.
+ * Everything goes through the `DataSource`, so live collections replace the
+ * fakes without touching a view.
+ *
+ * A record is labelled by its own `display.label` field (the first of `name`,
+ * `title`, `label`, `code` when undeclared; see `display.ts`). A
+ * Customer or Vendor has none: its name lives on its Profile, so it is joined
+ * to one (the "ship a selector instead" case of happyvertical/smrt#3599).
+ */
+import { getModelByQualifiedName } from "../catalog/index.js";
+import { displayLabel, partyField, recordName } from "./display.js";
+import { labelKey } from "./format.js";
+export const PROFILE = '@happyvertical/smrt-profiles:Profile';
+export const CUSTOMER = '@happyvertical/smrt-commerce:Customer';
+export const VENDOR = '@happyvertical/smrt-commerce:Vendor';
+const SEARCH_LIMIT = 20;
+function modelNamed(qualified) {
+    const found = getModelByQualifiedName(qualified);
+    if (!found)
+        throw new Error(`The catalog has no model ${qualified}`);
+    return found.model;
+}
+/** The first eight characters of an id: what is left when nothing names it. */
+export function shortId(id) {
+    return String(id ?? '').slice(0, 8);
+}
+/** Does the model get its name from a Profile (`profileId` referencing one)? */
+export function isProfileLabelled(model) {
+    return model.fields.some((f) => f.name === 'profileId' && f.related === PROFILE);
+}
+async function profileOf(source, record) {
+    return typeof record.profileId === 'string' && record.profileId
+        ? source.get(modelNamed(PROFILE), record.profileId)
+        : undefined;
+}
+/** How many relations deep a label may reach (allocation > invoice > customer). */
+const LABEL_DEPTH = 3;
+/** The text that names one record. Never an empty string. */
+export async function recordLabel(source, model, record, depth = 0) {
+    if (isProfileLabelled(model)) {
+        const profile = await profileOf(source, record);
+        const name = profile && displayLabel(modelNamed(PROFILE), profile);
+        if (name)
+            return name;
+    }
+    const party = partyField(model.fields, record);
+    const target = party?.related
+        ? getModelByQualifiedName(party.related)?.model
+        : undefined;
+    let partyLabel;
+    if (party && target && depth < LABEL_DEPTH) {
+        const found = await source.get(target, String(record[party.name]));
+        if (found) {
+            partyLabel = await recordLabel(source, target, found, depth + 1);
+        }
+    }
+    return recordName(model, record, () => partyLabel) ?? shortId(record.id);
+}
+/**
+ * The labels of every record the `fields` of `rows` point at, keyed by
+ * {@link labelKey}. A pointer to a record that is gone has no entry, so a view
+ * falls back to a short id rather than showing nothing.
+ */
+export async function relationLabels(source, fields, rows) {
+    const labels = new Map();
+    for (const field of fields) {
+        const targetId = field.related;
+        if (!targetId)
+            continue;
+        const target = getModelByQualifiedName(targetId)?.model;
+        if (!target)
+            continue;
+        const ids = new Set(rows
+            .map((row) => row[field.name])
+            .filter((id) => typeof id === 'string' && id !== ''));
+        for (const id of ids) {
+            if (labels.has(labelKey(targetId, id)))
+                continue;
+            const record = await source.get(target, id);
+            if (record) {
+                labels.set(labelKey(targetId, id), await recordLabel(source, target, record));
+            }
+        }
+    }
+    return labels;
+}
+const matches = (text, query) => text.toLowerCase().includes(query.trim().toLowerCase());
+/** Generic relation search: records of `target` whose label matches. */
+export async function searchRelated(source, target, query) {
+    const found = [];
+    for (const record of await source.list(target)) {
+        const label = await recordLabel(source, target, record);
+        if (matches(label, query))
+            found.push({ id: record.id, label });
+        if (found.length >= SEARCH_LIMIT)
+            break;
+    }
+    return found;
+}
+/** One related record as an option, or null when it is gone. */
+export async function resolveRelated(source, target, id) {
+    const record = await source.get(target, id);
+    return record
+        ? { id: record.id, label: await recordLabel(source, target, record) }
+        : null;
+}
+const text = (value) => typeof value === 'string' && value !== '' ? value : undefined;
+async function profileData(source, record) {
+    const profile = await profileOf(source, record);
+    return {
+        ...(profile ? { id: profile.id } : {}),
+        name: (profile && displayLabel(modelNamed(PROFILE), profile)) ??
+            shortId(record.id),
+        ...(text(profile?.email) ? { email: text(profile?.email) } : {}),
+    };
+}
+/** A Customer row joined to its Profile, as the commerce party DTO. */
+export async function customerData(source, record) {
+    return {
+        id: record.id,
+        ...(text(record.profileId) ? { profileId: text(record.profileId) } : {}),
+        profile: await profileData(source, record),
+        status: text(record.status) ?? '',
+        ...(text(record.customerType)
+            ? { customerType: text(record.customerType) }
+            : {}),
+        ...(typeof record.creditLimit === 'number'
+            ? { creditLimitMinor: record.creditLimit }
+            : {}),
+        ...(text(record.paymentTerms)
+            ? { paymentTerms: text(record.paymentTerms) }
+            : {}),
+    };
+}
+/** A Vendor row joined to its Profile, as the commerce party DTO. */
+export async function vendorData(source, record) {
+    return {
+        id: record.id,
+        ...(text(record.profileId) ? { profileId: text(record.profileId) } : {}),
+        profile: await profileData(source, record),
+        status: text(record.status) ?? '',
+        ...(typeof record.leadTimeDays === 'number'
+            ? { leadTimeDays: record.leadTimeDays }
+            : {}),
+        ...(text(record.currency) ? { currency: text(record.currency) } : {}),
+    };
+}
+/** Customers whose profile name (or email) matches, joined to their Profiles. */
+export async function searchCustomers(source, query) {
+    const found = [];
+    for (const record of await source.list(modelNamed(CUSTOMER))) {
+        const data = await customerData(source, record);
+        if (matches(data.profile.name, query))
+            found.push(data);
+        if (found.length >= SEARCH_LIMIT)
+            break;
+    }
+    return found;
+}
+export async function resolveCustomer(source, id) {
+    const record = await source.get(modelNamed(CUSTOMER), id);
+    return record ? customerData(source, record) : null;
+}
+export async function searchVendors(source, query) {
+    const found = [];
+    for (const record of await source.list(modelNamed(VENDOR))) {
+        const data = await vendorData(source, record);
+        if (matches(data.profile.name, query))
+            found.push(data);
+        if (found.length >= SEARCH_LIMIT)
+            break;
+    }
+    return found;
+}
+export async function resolveVendor(source, id) {
+    const record = await source.get(modelNamed(VENDOR), id);
+    return record ? vendorData(source, record) : null;
+}

package/dist/data/packs.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Sample-data packs. The generator draws names, prices, descriptions and the
+ * like from the ACTIVE pack: the generic one until a cookbook is applied, then
+ * that cookbook's (same id). Every value is fixed text, so a pack is as
+ * deterministic as the seed. Money is integer minor units (cents).
+ */
+/** What a sample product is, as the pack describes it. */
+export interface PackProduct {
+    name: string;
+    price: number;
+    description?: string;
+    category?: string;
+    /** `material` for things bought in (ingredients, steel); `product` for things sold. */
+    productType?: 'product' | 'material' | 'assembly';
+    /** Index into the pack's `locations` where this is counted; omitted: the first. */
+    at?: number;
+    /** How many of it a line item sells, `[min, max]`; omitted: the pack's. */
+    quantity?: [number, number];
+}
+/** A line item: a service or part as an invoice or order would say it. */
+export interface PackLine {
+    description: string;
+    price: number;
+    /** How many a line sells, `[min, max]` (`[1, 1]`: always one); omitted: the pack's. */
+    quantity?: [number, number];
+}
+export interface PackLocation {
+    code: string;
+    name: string;
+    kind: string;
+}
+export interface SamplePack {
+    id: string;
+    /**
+     * Rows 0-4 are what sample relations point at, so keep sellable items first.
+     */
+    products: readonly PackProduct[];
+    /** Line descriptions that are not products (labour, fabrication, passes). */
+    lines?: readonly PackLine[];
+    /** Customer profile names (8). Vendors take the next five profiles. */
+    customers?: readonly string[];
+    vendors?: readonly string[];
+    /**
+     * Staff who lead events and jobs (instructors, technicians, crew leads):
+     * Profiles of their own after the customers and vendors, so an organizer is
+     * never a customer.
+     */
+    instructors?: readonly string[];
+    /** Notes on documents (orders, invoices, estimates). */
+    notes?: readonly string[];
+    /** Notes about a customer (a member's preferences); omitted: `notes`. */
+    customerNotes?: readonly string[];
+    /** Notes about a vendor; omitted: `notes`. */
+    vendorNotes?: readonly string[];
+    /**
+     * Descriptions by model name (`Event`, `EventSeries`, `EventType`, `Place`).
+     * Where the pack names that model's rows, entry `n` describes name `n`.
+     * Never notes: a class is not described by a member's preferences.
+     */
+    descriptions?: Readonly<Record<string, readonly string[]>>;
+    /** Default `[min, max]` quantity of a line item; omitted: 1 to 5. */
+    lineQuantity?: [number, number];
+    terms?: readonly string[];
+    /** Event names; entry `n` suits `eventTypes[n % 5]`. */
+    eventNames?: readonly string[];
+    eventTypes?: readonly string[];
+    seriesNames?: readonly string[];
+    /** Places events happen at, and what kinds of place they are. */
+    placeNames?: readonly string[];
+    placeTypes?: readonly string[];
+    /** Default sales tax rate (fraction) of the cookbook; omitted: random rates. */
+    taxRate?: number;
+    locations?: readonly PackLocation[];
+    /** Sample rows per model id, where the pack needs more than the default. */
+    rowCounts?: Readonly<Record<string, number>>;
+    /** Weighted picks for an enumerated field, keyed `Model.field`. */
+    weights?: Readonly<Record<string, Readonly<Record<string, number>>>>;
+}
+export declare const GENERIC_PACK: SamplePack;
+/** The packs that ship with cookbooks, by cookbook id. */
+export declare const COOKBOOK_PACKS: Readonly<Record<string, SamplePack>>;
+/** The pack the generator reads right now. */
+export declare function getSamplePack(): SamplePack;
+/**
+ * Switch the pack to a cookbook's (unknown or null: the generic one). Rows
+ * already generated are not touched; the data source's `reset` regenerates.
+ */
+export declare function setSamplePack(cookbookId: string | null | undefined): SamplePack;
+/**
+ * The app's own tax-rate setting, when it states one: sample line items use it
+ * instead of the pack's. Takes effect when sample rows are next generated.
+ */
+export declare function setSampleTaxRate(rate: number | undefined): void;
+/** The sample tax rate: the app's setting, else the pack's (omitted: random). */
+export declare function getSampleTaxRate(): number | undefined;