better-supabase 0.13.0 → 0.15.0

package/dist/blocks/assets/index.d.ts

@@ -0,0 +1,281 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { Ct as Events } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { t as AssetsSqlOptions } from "../../options-D1hSuf50.js";
+import { c as BlockOf, rn as RecordBinding } from "../../define-block-BVcLQ3DF.js";
+//#region src/blocks/assets/assets.d.ts
+interface AssetsOptions extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
+  readonly schema?: string;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Assets>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** A point in WGS 84 degrees. */
+interface GeoPoint {
+  readonly latitude: number;
+  readonly longitude: number;
+}
+/** A GeoJSON Polygon or MultiPolygon, for a location's area. */
+type GeoArea = Readonly<Record<string, unknown>>;
+/** A place in the hierarchy: a site, building, floor, unit or room. */
+interface AssetLocation {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly parentId?: string;
+  readonly kind: string;
+  readonly name: string;
+  /** Unique in the organization. */
+  readonly code?: string;
+  readonly address: Readonly<Record<string, unknown>>;
+  readonly point?: GeoPoint;
+  /** The outline as GeoJSON, with the `postgis` option. */
+  readonly area?: GeoArea;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly archivedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** One step of a location's path from the top. */
+interface AssetLocationStep {
+  readonly id: string;
+  readonly kind: string;
+  readonly name: string;
+}
+interface AssetLocationDetail extends AssetLocation {
+  /** From the top down to this location. */
+  readonly path: readonly AssetLocationStep[];
+  /** Open sublocations. */
+  readonly locations: number;
+  /** Assets in service at this location. */
+  readonly assets: number;
+}
+interface AssetLocationInput {
+  readonly kind: string;
+  readonly name: string;
+  readonly parentId?: string;
+  readonly code?: string;
+  readonly address?: Readonly<Record<string, unknown>>;
+  readonly point?: GeoPoint;
+  /** Needs the `postgis` option. */
+  readonly area?: GeoArea;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** What to change; `null` clears an optional field. */
+interface AssetLocationPatch {
+  readonly kind?: string;
+  readonly name?: string;
+  readonly parentId?: string | null;
+  readonly code?: string | null;
+  readonly address?: Readonly<Record<string, unknown>> | null;
+  readonly point?: GeoPoint | null;
+  readonly area?: GeoArea | null;
+  readonly metadata?: Readonly<Record<string, unknown>> | null;
+}
+type AssetStatus = "active" | "maintenance" | "retired";
+/** Who or what holds an asset: `member` (a user id) or a record. */
+interface AssetAssignee {
+  readonly type: string;
+  readonly id: string;
+}
+interface Asset {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly locationId?: string;
+  readonly kind: string;
+  readonly name: string;
+  /** The asset tag, unique in the organization. */
+  readonly tag?: string;
+  readonly serialNumber?: string;
+  readonly status: AssetStatus;
+  readonly assignee?: AssetAssignee;
+  /** Where a moving asset was last seen. */
+  readonly point?: GeoPoint;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly retiredAt?: Temporal.Instant;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** The records that name an asset, when their blocks are installed. */
+interface AssetLinks {
+  readonly bookingResources: readonly {
+    readonly id: string;
+    readonly name: string;
+  }[];
+  /** Open work items, newest first, at most 50. */
+  readonly workItems: readonly {
+    readonly id: string;
+    readonly title: string;
+  }[];
+}
+interface AssetDetail extends Asset {
+  readonly locationPath: readonly AssetLocationStep[];
+  readonly links: AssetLinks;
+}
+interface AssetInput {
+  readonly kind: string;
+  readonly name: string;
+  readonly locationId?: string;
+  readonly tag?: string;
+  readonly serialNumber?: string;
+  readonly point?: GeoPoint;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** What to change; `null` clears an optional field. Retiring releases it. */
+interface AssetPatch {
+  readonly kind?: string;
+  readonly name?: string;
+  readonly locationId?: string | null;
+  readonly tag?: string | null;
+  readonly serialNumber?: string | null;
+  readonly status?: AssetStatus;
+  readonly point?: GeoPoint | null;
+  readonly metadata?: Readonly<Record<string, unknown>> | null;
+}
+interface AssetListOptions {
+  readonly locationId?: string;
+  /** With `locationId`, also the assets below it. */
+  readonly includeSublocations?: boolean;
+  readonly kind?: string;
+  readonly status?: AssetStatus;
+  readonly assignee?: AssetAssignee;
+  /** Part of the name, or an exact tag or serial number. */
+  readonly query?: string;
+  /** Pages back from an asset's `createdAt`. */
+  readonly before?: Temporal.Instant;
+  readonly pageSize?: number;
+}
+interface AssetAssignment {
+  readonly id: string;
+  readonly assetId: string;
+  readonly assignee: AssetAssignee;
+  readonly note?: string;
+  readonly assignedBy?: string;
+  readonly assignedAt: Temporal.Instant;
+  readonly releasedAt?: Temporal.Instant;
+}
+interface AssetsNearOptions extends GeoPoint {
+  /** Above 0, at most 1,000,000. */
+  readonly radiusMeters: number;
+  readonly kind?: string;
+  readonly pageSize?: number;
+}
+/** What is near a point, nearest first. */
+interface AssetsNear {
+  readonly assets: readonly (Asset & {
+    readonly distanceMeters: number;
+  })[];
+  readonly locations: readonly (AssetLocation & {
+    readonly distanceMeters: number;
+  })[];
+}
+/** A record that can name an asset. */
+interface AssetLinkTarget {
+  readonly type: "booking_resource" | "work_item";
+  readonly id: string;
+}
+interface Assets {
+  /** Needs `assets.manage`. */
+  createLocation(input: AssetLocationInput): AsyncResult<AssetLocation>;
+  updateLocation(locationId: string, patch: AssetLocationPatch): AsyncResult<AssetLocation>;
+  /** Only a location without open sublocations or assets in service. */
+  archiveLocation(locationId: string): AsyncResult<AssetLocation>;
+  location(locationId: string): AsyncResult<AssetLocationDetail>;
+  /** The locations under `parentId`, or the top ones. */
+  locations(options?: {
+    readonly parentId?: string;
+    readonly includeArchived?: boolean;
+    readonly pageSize?: number;
+  }): AsyncResult<readonly AssetLocation[]>;
+  /** Needs `assets.manage`. */
+  createAsset(input: AssetInput): AsyncResult<Asset>;
+  updateAsset(assetId: string, patch: AssetPatch): AsyncResult<Asset>;
+  asset(assetId: string): AsyncResult<AssetDetail>;
+  /** Newest first, in the block's tenant. */
+  assets(options?: AssetListOptions): AsyncResult<readonly Asset[]>;
+  /** The assets a member or a record holds. The record decides the tenant. */
+  assignedTo(assignee: RecordRef | AssetAssignee, options?: {
+    readonly pageSize?: number;
+  }): AsyncResult<readonly Asset[]>;
+  /** Needs `assets.assign`. Ends the previous assignment. */
+  assign(assetId: string, assignee: AssetAssignee, options?: {
+    readonly note?: string;
+  }): AsyncResult<Asset>;
+  release(assetId: string): AsyncResult<Asset>;
+  assignments(assetId: string, options?: {
+    readonly pageSize?: number;
+  }): AsyncResult<readonly AssetAssignment[]>;
+  /** Assets and locations within a radius, in the block's tenant. */
+  near(options: AssetsNearOptions): AsyncResult<AssetsNear>;
+  /** Locations whose area contains a point. Needs the `postgis` option. */
+  locationsAt(point: GeoPoint): AsyncResult<readonly AssetLocation[]>;
+  /** Names (or with `null`, clears) the asset a record is about. */
+  link(target: AssetLinkTarget, assetId: string | null): AsyncResult<AssetLinkTarget & {
+    readonly assetId: string | null;
+  }>;
+}
+/** The `assets` SQL module as typed calls. */
+export declare function createAssets(options: AssetsOptions): Assets;
+//#endregion
+//#region src/blocks/assets/events.d.ts
+/**
+ * `asset_location.created`, `asset_location.updated` and
+ * `asset_location.archived`.
+ */
+interface AssetLocationEventData {
+  readonly organizationId: string;
+  /** The location. */
+  readonly id: string;
+  /** `site`, `building`, `unit`, or the app's own kind. */
+  readonly kind: string;
+  readonly name: string;
+  readonly parentId: string | null;
+}
+/** `asset.created`, `asset.updated`, `asset.assigned` and `asset.released`. */
+interface AssetEventData {
+  readonly organizationId: string;
+  /** The asset. */
+  readonly id: string;
+  readonly kind: string;
+  readonly name: string;
+  /** `active`, `maintenance` or `retired`. */
+  readonly status: string;
+  readonly locationId: string | null;
+  /** `member` or a record type such as `party`, while assigned. */
+  readonly assigneeType: string | null;
+  readonly assigneeId: string | null;
+}
+/** The events of the `assets` block: type to data. */
+type AssetsEvents = {
+  readonly "asset_location.created": AssetLocationEventData;
+  readonly "asset_location.updated": AssetLocationEventData;
+  readonly "asset_location.archived": AssetLocationEventData;
+  readonly "asset.created": AssetEventData;
+  readonly "asset.updated": AssetEventData;
+  readonly "asset.assigned": AssetEventData;
+  readonly "asset.released": AssetEventData;
+};
+/** The `assets` block's event types, for its manifest and `onBlockEvent`. */
+export declare const assetsEvents: Events<AssetsEvents>;
+//#endregion
+//#region src/blocks/assets/record-binding.d.ts
+/** The assets a record holds, such as a party's devices or vehicles. */
+export declare const assetsBinding: RecordBinding<Assets, readonly Asset[]>;
+//#endregion
+//#region src/blocks/assets/manifest.d.ts
+/** The `assets` block's manifest (ADR 0029). */
+export declare const assetsBlock: BlockOf<"assets", typeof createAssets, AssetsEvents, Record<never, never>, never, typeof assetsBinding>;
+//#endregion
+export { type Asset, type AssetAssignee, type AssetAssignment, type AssetDetail, type AssetEventData, type AssetInput, type AssetLinkTarget, type AssetLinks, type AssetListOptions, type AssetLocation, type AssetLocationDetail, type AssetLocationEventData, type AssetLocationInput, type AssetLocationPatch, type AssetLocationStep, type AssetPatch, type AssetStatus, type Assets, type AssetsEvents, type AssetsNear, type AssetsNearOptions, type AssetsOptions, type AssetsSqlOptions, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type GeoArea, type GeoPoint, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/assets/index.js

@@ -0,0 +1,288 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as assetsSqlOptions } from "../../options-CYV4iZiQ.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { t as defineRecordBinding } from "../../record-bindings-DkBJpC5A.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+//#region src/blocks/assets/assets.ts
+const STATUSES = [
+	"active",
+	"maintenance",
+	"retired"
+];
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+const objectOf = (value) => isRecord(value) ? value : {};
+const numberOf = (value) => typeof value === "number" ? value : void 0;
+function pointOf(row) {
+	const latitude = numberOf(row["latitude"]);
+	const longitude = numberOf(row["longitude"]);
+	return latitude === void 0 || longitude === void 0 ? void 0 : {
+		latitude,
+		longitude
+	};
+}
+function stepsOf(value, fn) {
+	return recordsOf(value, fn).map((step) => ({
+		id: textOf(step["id"]),
+		kind: textOf(step["kind"]),
+		name: textOf(step["name"])
+	}));
+}
+function locationOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		kind: textOf(row["kind"]),
+		name: textOf(row["name"]),
+		address: objectOf(row["address"]),
+		metadata: objectOf(row["metadata"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("parentId", optionalText(row["parentId"])),
+		...optional("code", optionalText(row["code"])),
+		...optional("point", pointOf(row)),
+		...optional("area", isRecord(row["area"]) ? row["area"] : void 0),
+		...optional("archivedAt", optionalInstant(row["archivedAt"]))
+	};
+}
+function assetOf(value, fn) {
+	const row = recordOf(value, fn);
+	const assigneeType = optionalText(row["assigneeType"]);
+	const assigneeId = optionalText(row["assigneeId"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		kind: textOf(row["kind"]),
+		name: textOf(row["name"]),
+		status: enumOrThrow(row["status"], STATUSES, "asset status"),
+		metadata: objectOf(row["metadata"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("assignee", assigneeType === void 0 || assigneeId === void 0 ? void 0 : {
+			type: assigneeType,
+			id: assigneeId
+		}),
+		...optional("locationId", optionalText(row["locationId"])),
+		...optional("tag", optionalText(row["tag"])),
+		...optional("serialNumber", optionalText(row["serialNumber"])),
+		...optional("point", pointOf(row)),
+		...optional("retiredAt", optionalInstant(row["retiredAt"])),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function assignmentOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		assetId: textOf(row["assetId"]),
+		assignee: {
+			type: textOf(row["assigneeType"]),
+			id: textOf(row["assigneeId"])
+		},
+		assignedAt: requiredInstant(row["assignedAt"], "assignedAt"),
+		...optional("note", optionalText(row["note"])),
+		...optional("assignedBy", optionalText(row["assignedBy"])),
+		...optional("releasedAt", optionalInstant(row["releasedAt"]))
+	};
+}
+const distanceOf = (row) => Number(row["distanceMeters"] ?? 0);
+/** The patch keys the SQL functions read, with a point split in two. */
+function patchArg(patch) {
+	const out = {};
+	const entries = Object.entries(patch);
+	for (const [key, value] of entries) {
+		if (value === void 0) continue;
+		if (key === "point") {
+			const point = isRecord(value) ? value : {};
+			out["latitude"] = point["latitude"] ?? null;
+			out["longitude"] = point["longitude"] ?? null;
+			continue;
+		}
+		out[key] = value;
+	}
+	return out;
+}
+/** The `assets` SQL module as typed calls. */
+function createAssets(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const tenant = () => requireOrganization(options.tenant);
+	const list = (organizationId, filter) => call("list_assets", {
+		tenant: organizationId,
+		location_id: filter.locationId ?? null,
+		include_sublocations: filter.includeSublocations ?? false,
+		kind: filter.kind ?? null,
+		status: filter.status ?? null,
+		assignee_type: filter.assignee?.type ?? null,
+		assignee_id: filter.assignee?.id ?? null,
+		query: filter.query ?? null,
+		before: instantArg(filter.before) ?? null,
+		page_size: filter.pageSize ?? null
+	}, (value) => recordsOf(value, "list_assets").map((row) => assetOf(row, "list_assets")));
+	return withBlockHooks({
+		createLocation: (input) => tenant().andThen((organizationId) => call("create_asset_location", {
+			tenant: organizationId,
+			kind: input.kind,
+			name: input.name,
+			parent_id: input.parentId ?? null,
+			code: input.code ?? null,
+			address: input.address ?? null,
+			latitude: input.point?.latitude ?? null,
+			longitude: input.point?.longitude ?? null,
+			area: input.area ?? null,
+			metadata: input.metadata ?? null
+		}, (value) => locationOf(value, "create_asset_location"))),
+		updateLocation: (locationId, patch) => call("update_asset_location", {
+			location_id: locationId,
+			patch: patchArg(patch)
+		}, (value) => locationOf(value, "update_asset_location")),
+		archiveLocation: (locationId) => call("archive_asset_location", { location_id: locationId }, (value) => locationOf(value, "archive_asset_location")),
+		location: (locationId) => call("get_asset_location", { location_id: locationId }, (value) => {
+			const row = recordOf(value, "get_asset_location");
+			return {
+				...locationOf(row, "get_asset_location"),
+				path: stepsOf(row["path"], "get_asset_location"),
+				locations: Number(row["locations"] ?? 0),
+				assets: Number(row["assets"] ?? 0)
+			};
+		}),
+		locations: (filter = {}) => tenant().andThen((organizationId) => call("list_asset_locations", {
+			tenant: organizationId,
+			parent_id: filter.parentId ?? null,
+			include_archived: filter.includeArchived ?? false,
+			page_size: filter.pageSize ?? null
+		}, (value) => recordsOf(value, "list_asset_locations").map((row) => locationOf(row, "list_asset_locations")))),
+		createAsset: (input) => tenant().andThen((organizationId) => call("create_asset", {
+			tenant: organizationId,
+			kind: input.kind,
+			name: input.name,
+			location_id: input.locationId ?? null,
+			tag: input.tag ?? null,
+			serial_number: input.serialNumber ?? null,
+			latitude: input.point?.latitude ?? null,
+			longitude: input.point?.longitude ?? null,
+			metadata: input.metadata ?? null
+		}, (value) => assetOf(value, "create_asset"))),
+		updateAsset: (assetId, patch) => call("update_asset", {
+			asset_id: assetId,
+			patch: patchArg(patch)
+		}, (value) => assetOf(value, "update_asset")),
+		asset: (assetId) => call("get_asset", { asset_id: assetId }, (value) => {
+			const row = recordOf(value, "get_asset");
+			const links = objectOf(row["links"]);
+			return {
+				...assetOf(row, "get_asset"),
+				locationPath: stepsOf(row["locationPath"], "get_asset"),
+				links: {
+					bookingResources: recordsOf(links["bookingResources"] ?? [], "get_asset").map((link) => ({
+						id: textOf(link["id"]),
+						name: textOf(link["name"])
+					})),
+					workItems: recordsOf(links["workItems"] ?? [], "get_asset").map((link) => ({
+						id: textOf(link["id"]),
+						title: textOf(link["title"])
+					}))
+				}
+			};
+		}),
+		assets: (filter = {}) => tenant().andThen((organizationId) => list(organizationId, filter)),
+		assignedTo: (assignee, filter = {}) => list(null, {
+			assignee: {
+				type: assignee.type,
+				id: assignee.id
+			},
+			...optional("pageSize", filter.pageSize)
+		}),
+		assign: (assetId, assignee, assign = {}) => call("assign_asset", {
+			asset_id: assetId,
+			assignee_type: assignee.type,
+			assignee_id: assignee.id,
+			note: assign.note ?? null
+		}, (value) => assetOf(value, "assign_asset")),
+		release: (assetId) => call("release_asset", { asset_id: assetId }, (value) => assetOf(value, "release_asset")),
+		assignments: (assetId, filter = {}) => call("asset_assignment_history", {
+			asset_id: assetId,
+			page_size: filter.pageSize ?? null
+		}, (value) => recordsOf(value, "asset_assignment_history").map((row) => assignmentOf(row, "asset_assignment_history"))),
+		near: (near) => tenant().andThen((organizationId) => call("assets_near", {
+			tenant: organizationId,
+			latitude: near.latitude,
+			longitude: near.longitude,
+			radius_meters: near.radiusMeters,
+			kind: near.kind ?? null,
+			page_size: near.pageSize ?? null
+		}, (value) => {
+			const row = recordOf(value, "assets_near");
+			return {
+				assets: recordsOf(row["assets"], "assets_near").map((item) => ({
+					...assetOf(item, "assets_near"),
+					distanceMeters: distanceOf(item)
+				})),
+				locations: recordsOf(row["locations"], "assets_near").map((item) => ({
+					...locationOf(item, "assets_near"),
+					distanceMeters: distanceOf(item)
+				}))
+			};
+		})),
+		locationsAt: (point) => tenant().andThen((organizationId) => call("asset_locations_at", {
+			tenant: organizationId,
+			latitude: point.latitude,
+			longitude: point.longitude
+		}, (value) => recordsOf(value, "asset_locations_at").map((row) => locationOf(row, "asset_locations_at")))),
+		link: (target, assetId) => call("set_asset_link", {
+			target_type: target.type,
+			target_id: target.id,
+			asset_id: assetId
+		}, () => ({
+			type: target.type,
+			id: target.id,
+			assetId
+		}))
+	}, options.hooks, {
+		block: "assets",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/assets/events.ts
+/** The `assets` block's event types, for its manifest and `onBlockEvent`. */
+const assetsEvents = defineEvents({
+	"asset_location.created": event(),
+	"asset_location.updated": event(),
+	"asset_location.archived": event(),
+	"asset.created": event(),
+	"asset.updated": event(),
+	"asset.assigned": event(),
+	"asset.released": event()
+});
+//#endregion
+//#region src/blocks/assets/record-binding.ts
+/** The assets a record holds, such as a party's devices or vehicles. */
+const assetsBinding = defineRecordBinding({
+	permissions: {
+		read: "read",
+		write: "assign"
+	},
+	module: "assets",
+	load: (client, subject) => client.assignedTo(subject),
+	events: ["asset.*"]
+});
+//#endregion
+//#region src/blocks/assets/manifest.ts
+/** The `assets` block's manifest (ADR 0029). */
+const assetsBlock = defineBlock({
+	name: "assets",
+	sql: ["assets"],
+	options: { assets: assetsSqlOptions },
+	events: assetsEvents,
+	create: createAssets,
+	record: assetsBinding,
+	category: "work"
+});
+//#endregion
+export { assetsBinding, assetsBlock, assetsEvents, createAssets, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/assignment/index.d.ts

@@ -0,0 +1,124 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { Ct as Events } from "../../events-vcqenSYU.js";
+import { p as AssignmentEventData } from "../../index-CG9rA8H8.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { h as FilterQuery } from "../../filter-query-BXLs72G9.js";
+import { Sn as EntitySchema, c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+//#region src/blocks/assignment/assignment.d.ts
+/** How a queue picks the next owner. */
+type AssignmentStrategy = "round_robin" | "weighted";
+/** A member in a queue's rotation. */
+interface AssignmentMember {
+  readonly userId: string;
+  /** The member's share in a weighted queue, 1 to 100. */
+  readonly weight: number;
+  /** Inactive members stay in the queue but get no records. */
+  readonly active: boolean;
+  readonly assignedCount: number;
+  readonly lastAssignedAt: Temporal.Instant | undefined;
+}
+/** A queue that picks owners for records of one subject type. */
+interface AssignmentQueue {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly name: string;
+  readonly subjectType: string;
+  readonly strategy: AssignmentStrategy;
+  /** The territory: records the queue takes. Undefined takes every record. */
+  readonly conditions: FilterQuery | undefined;
+  /** Queues are tried by rank, lowest first, then by name. */
+  readonly rank: number;
+  readonly enabled: boolean;
+  readonly members: readonly AssignmentMember[];
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** What `saveQueue` takes. Leave `id` out to create a queue. */
+interface AssignmentQueueInput {
+  readonly id?: string;
+  readonly name?: string;
+  readonly subjectType?: string;
+  readonly strategy?: AssignmentStrategy;
+  /** `null` clears the territory. */
+  readonly conditions?: FilterQuery | null;
+  readonly rank?: number;
+  readonly enabled?: boolean;
+}
+/** A pick: the queue that matched and the member it chose. */
+interface Assignment {
+  readonly queueId: string;
+  readonly userId: string;
+  readonly strategy: AssignmentStrategy;
+}
+/** A past pick for a record. */
+interface AssignmentRecord {
+  /** Undefined when the queue was removed since. */
+  readonly queueId: string | undefined;
+  /** Undefined when the user was deleted since. */
+  readonly userId: string | undefined;
+  readonly assignedAt: Temporal.Instant;
+}
+interface AssignmentClient {
+  saveQueue(organizationId: string, queue: AssignmentQueueInput): AsyncResult<AssignmentQueue>;
+  /** Replaces the queue's members; members who stay keep their turn. */
+  setMembers(queueId: string, members: readonly {
+    readonly userId: string;
+    readonly weight?: number;
+    readonly active?: boolean;
+  }[]): AsyncResult<AssignmentQueue>;
+  removeQueue(queueId: string): AsyncResult<boolean>;
+  queues(organizationId: string, options?: {
+    readonly subjectType?: string;
+  }): AsyncResult<AssignmentQueue[]>;
+  /**
+   * Picks an owner for a record from the first queue whose territory matches
+   * `fields` (keyed as the rule fields' columns). Undefined when no queue
+   * matches. Writing the owner onto the record is up to the app.
+   */
+  assign(organizationId: string, subject: {
+    readonly type: string;
+    readonly id: string;
+    readonly fields?: Readonly<Record<string, unknown>>;
+  }): AsyncResult<Assignment | undefined>;
+  /** The picks for a record, newest first. */
+  history(organizationId: string, subject: {
+    readonly type: string;
+    readonly id: string;
+  }, options?: {
+    readonly limit?: number;
+  }): AsyncResult<AssignmentRecord[]>;
+}
+interface AssignmentOptions extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
+  readonly schema?: string;
+  readonly hooks?: NoInfer<BlockHooks<AssignmentClient>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+export declare function createAssignment(options: AssignmentOptions): AssignmentClient;
+//#endregion
+//#region src/blocks/assignment/events.d.ts
+/** The events of the `assignment` block: type to data. */
+type AssignmentEvents = {
+  readonly "subject.assigned": AssignmentEventData;
+};
+/** The `assignment` block's event types, for its manifest and `onBlockEvent`. */
+export declare const assignmentEvents: Events<AssignmentEvents>;
+//#endregion
+//#region src/blocks/assignment/manifest.d.ts
+/** The `assignment` block's manifest (ADR 0029). */
+export declare const assignmentBlock: BlockOf<"assignment", typeof createAssignment, AssignmentEvents>;
+//#endregion
+//#region src/blocks/assignment/schemas.d.ts
+/** What `saveQueue` takes. The SQL checks the territory against the rule fields. */
+export declare const assignmentQueueInputSchema: EntitySchema<AssignmentQueueInput>;
+//#endregion
+export { type Assignment, type AssignmentClient, type AssignmentMember, type AssignmentOptions, type AssignmentQueue, type AssignmentQueueInput, type AssignmentRecord, type AssignmentStrategy, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };