@segmentstream/app 0.0.0-stage → 0.38.0

package/dist/ontology-wire.js

@@ -0,0 +1,355 @@
+import { toCamelCase, toSnakeCase } from "./ontology-names.js";
+const FILTER_OPERATORS = [
+    "eq",
+    "ne",
+    "in",
+    "isNull",
+    "contains",
+    "startsWith",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "between",
+    "has",
+    "hasAny",
+];
+const SYSTEM_FIELDS = ["id", "created_at", "updated_at", "created_by", "updated_by"];
+/** The built-in entity of members and services, whose `roles` field lists role names. */
+const USER = "user";
+/** The generated `user` actions that take role names; each, with the others below, returns the record. */
+const USER_ROLE_ACTIONS = ["invite", "grant_roles", "revoke_roles"];
+const USER_RECORD_ACTIONS = [...USER_ROLE_ACTIONS, "deactivate", "reactivate"];
+/** Whether a generated action of `user` answers with the updated user record. */
+export function returnsUserRecord(entity, action) {
+    return entity === USER && USER_RECORD_ACTIONS.includes(action);
+}
+/**
+ * Role names are snake_case on the wire and camelCase in the app, as `requireUser().roles` has
+ * them; `convert` turns one, or each of a list, into the other.
+ */
+function roleNames(value, convert) {
+    if (typeof value === "string") {
+        return convert(value);
+    }
+    return Array.isArray(value)
+        ? value.map((name) => (typeof name === "string" ? convert(name) : name))
+        : value;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * A relationship with a warehouse-backed end is matched by value through `on`: it has no
+ * `<name>_id` field, and the ontology service cannot traverse or filter through it.
+ */
+function isValueMatched(relationship) {
+    return relationship.on !== undefined && relationship.on !== null;
+}
+/** Catalog metadata distinguishes relationship filters from opaque JSON property values. */
+export async function encodeWhere(input) {
+    const { where, entity, getCatalog } = input;
+    if (where === undefined) {
+        return where;
+    }
+    const catalog = await getCatalog();
+    return whereFromCatalog({ where, entity, catalog });
+}
+function whereFromCatalog(input) {
+    const { where, entity, catalog } = input;
+    const definition = catalog.entities.find((candidate) => candidate.name === entity);
+    const encodedWhere = Object.create(null);
+    for (const [field, condition] of Object.entries(where)) {
+        if (field === "and" || field === "or") {
+            const conditions = condition;
+            encodedWhere[field] = conditions.map((child) => whereFromCatalog({ where: child, entity, catalog }));
+            continue;
+        }
+        if (field === "not") {
+            encodedWhere[field] = whereFromCatalog({ where: condition, entity, catalog });
+            continue;
+        }
+        const wireField = toSnakeCase(field);
+        const relationship = relationshipTarget({ field: wireField, entity, definition, catalog });
+        if (relationship !== undefined && isRecord(condition)) {
+            encodedWhere[wireField] = relationshipFilterToWire({ condition, relationship, catalog });
+            continue;
+        }
+        encodedWhere[wireField] =
+            entity === USER && wireField === "roles"
+                ? rolesFilterToWire(condition)
+                : fieldFilterToWire({ field: wireField, condition, definition });
+    }
+    return encodedWhere;
+}
+function relationshipTarget(input) {
+    const { field, entity, definition, catalog } = input;
+    const forward = definition?.relationships.find((candidate) => candidate.name === field && !isValueMatched(candidate));
+    if (forward !== undefined) {
+        return { entity: forward.to, many: forward.cardinality === "many" };
+    }
+    for (const candidate of catalog.entities) {
+        const inverse = candidate.relationships.find((relationship) => relationship.to === entity &&
+            relationship.inverse === field &&
+            !isValueMatched(relationship));
+        if (inverse !== undefined) {
+            return { entity: candidate.name, many: true };
+        }
+    }
+    return undefined;
+}
+function relationshipFilterToWire(input) {
+    const { condition, relationship, catalog } = input;
+    const entity = relationship.entity;
+    if (!relationship.many) {
+        return whereFromCatalog({ where: condition, entity, catalog });
+    }
+    const encodedQuantifiers = Object.create(null);
+    for (const [quantifier, child] of Object.entries(condition)) {
+        encodedQuantifiers[quantifier] = whereFromCatalog({ where: child, entity, catalog });
+    }
+    return encodedQuantifiers;
+}
+function isGeneratedField(field, definition) {
+    if (SYSTEM_FIELDS.includes(field)) {
+        return true;
+    }
+    return (definition?.relationships.some((relationship) => relationship.cardinality === "one" &&
+        !isValueMatched(relationship) &&
+        `${relationship.name}_id` === field) ?? false);
+}
+function fieldFilterToWire(input) {
+    const { field, condition, definition } = input;
+    const property = definition?.properties.find((candidate) => candidate.name === field);
+    if (!isRecord(condition)) {
+        return selectToWire(condition, property);
+    }
+    if (property === undefined && !isGeneratedField(field, definition)) {
+        return condition;
+    }
+    const operatorFilter = Object.keys(condition).every((operator) => FILTER_OPERATORS.includes(operator));
+    if (property?.type === "json" && !operatorFilter) {
+        return condition;
+    }
+    const encodedFilter = Object.create(null);
+    for (const [operator, operand] of Object.entries(condition)) {
+        encodedFilter[operatorToWire(operator)] = selectToWire(operand, property);
+    }
+    return encodedFilter;
+}
+function rolesFilterToWire(condition) {
+    if (!isRecord(condition)) {
+        return roleNames(condition, toSnakeCase);
+    }
+    return Object.fromEntries(Object.entries(condition).map(([operator, operand]) => [
+        operatorToWire(operator),
+        operator === "isNull" ? operand : roleNames(operand, toSnakeCase),
+    ]));
+}
+function operatorToWire(operator) {
+    if (operator === "isNull") {
+        return "is_null";
+    }
+    if (operator === "startsWith") {
+        return "starts_with";
+    }
+    if (operator === "hasAny") {
+        return "has_any";
+    }
+    return operator;
+}
+export function queryToWire(query) {
+    const { orderBy, where, ...rest } = query;
+    return {
+        ...rest,
+        ...(query.select === undefined ? {} : { select: query.select.map(toSnakeCase) }),
+        ...(orderBy === undefined
+            ? {}
+            : { order_by: orderBy.map((order) => ({ ...order, field: toSnakeCase(order.field) })) }),
+        ...(query.include === undefined ? {} : { include: includeToWire(query.include) }),
+        ...(where === undefined ? {} : { where }),
+    };
+}
+/**
+ * `include` with snake_case names, as an object: a list of names, `["assignedOwner"]`, becomes
+ * `{ assigned_owner: true }`, which every version of the ontology service accepts.
+ */
+export function includeToWire(include) {
+    const entries = isIncludeList(include)
+        ? include.map((name) => [name, true])
+        : Object.entries(include);
+    return Object.fromEntries(entries.map(([name, value]) => [toSnakeCase(name), value]));
+}
+function isIncludeList(include) {
+    return Array.isArray(include);
+}
+function selectToWire(value, property) {
+    if (property?.type !== "select") {
+        return value;
+    }
+    const convert = (child) => typeof child === "string" &&
+        property.options?.some((option) => option.value === toSnakeCase(child))
+        ? toSnakeCase(child)
+        : child;
+    return Array.isArray(value) ? value.map(convert) : convert(value);
+}
+/** Decode record fields and included relationships without descending into JSON properties. */
+export function recordFromWire(value, entity, catalog) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const definition = catalog.entities.find((candidate) => candidate.name === entity);
+    return Object.fromEntries(Object.entries(value).map(([field, child]) => {
+        const property = definition?.properties.find((candidate) => candidate.name === field);
+        if (property?.type === "select" && typeof child === "string") {
+            return [toCamelCase(field), toCamelCase(child)];
+        }
+        if (entity === USER && field === "roles") {
+            return [field, roleNames(child, toCamelCase)];
+        }
+        const relationship = relationshipTarget({ field, entity, definition, catalog });
+        if (relationship !== undefined) {
+            const decoded = Array.isArray(child)
+                ? child.map((record) => recordFromWire(record, relationship.entity, catalog))
+                : recordFromWire(child, relationship.entity, catalog);
+            return [toCamelCase(field), decoded];
+        }
+        return [toCamelCase(field), child];
+    }));
+}
+function schemaInputToWire(value, schema, definitions) {
+    if (schema.$ref?.startsWith("#/$defs/")) {
+        const target = definitions[schema.$ref.slice("#/$defs/".length)];
+        return target === undefined ? value : schemaInputToWire(value, target, definitions);
+    }
+    const alternatives = schema.anyOf ?? schema.oneOf;
+    if (alternatives !== undefined) {
+        const object = alternatives.find((candidate) => matchesObjectSchema(value, candidate, definitions));
+        const array = alternatives.find((candidate) => candidate.items !== undefined && Array.isArray(value));
+        const literals = alternatives.flatMap((candidate) => candidate.enum ?? (candidate.const === undefined ? [] : [candidate.const]));
+        if (typeof value === "string" && literals.includes(toSnakeCase(value))) {
+            return toSnakeCase(value);
+        }
+        const target = object ?? array;
+        return target === undefined ? value : schemaInputToWire(value, target, definitions);
+    }
+    if (typeof value === "string" &&
+        (schema.enum?.includes(toSnakeCase(value)) || schema.const === toSnakeCase(value))) {
+        return toSnakeCase(value);
+    }
+    if (Array.isArray(value) && schema.items !== undefined) {
+        return value.map((child) => schemaInputToWire(child, schema.items, definitions));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    if (schema.properties === undefined) {
+        const childSchema = schema.additionalProperties;
+        return typeof childSchema === "object"
+            ? Object.fromEntries(Object.entries(value).map(([key, child]) => [
+                key,
+                schemaInputToWire(child, childSchema, definitions),
+            ]))
+            : value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([field, child]) => {
+        const wireField = toSnakeCase(field);
+        const childSchema = schema.properties?.[wireField];
+        return [
+            wireField,
+            childSchema === undefined ? child : schemaInputToWire(child, childSchema, definitions),
+        ];
+    }));
+}
+function matchesObjectSchema(value, schema, definitions) {
+    if (schema.$ref?.startsWith("#/$defs/")) {
+        const target = definitions[schema.$ref.slice("#/$defs/".length)];
+        return (target !== undefined && target !== schema && matchesObjectSchema(value, target, definitions));
+    }
+    if (!isRecord(value) || schema.properties === undefined) {
+        return false;
+    }
+    if (schema.required?.some((key) => !Object.hasOwn(value, key) && !Object.hasOwn(value, toCamelCase(key)))) {
+        return false;
+    }
+    return Object.entries(schema.properties).every(([key, childSchema]) => {
+        if (childSchema.const === undefined) {
+            return true;
+        }
+        const child = value[key] ?? value[toCamelCase(key)];
+        return (child === childSchema.const ||
+            (typeof child === "string" && toSnakeCase(child) === childSchema.const));
+    });
+}
+export function actionInputToWire(given, entity, action, catalog) {
+    const definition = catalog.entities.find((candidate) => candidate.name === entity);
+    const authored = definition?.actions?.find((candidate) => candidate.name === action);
+    const input = entity === USER && USER_ROLE_ACTIONS.includes(action) && isRecord(given) && "roles" in given
+        ? { ...given, roles: roleNames(given.roles, toSnakeCase) }
+        : given;
+    if (authored !== undefined) {
+        return schemaInputToWire(input, authored.input, authored.input.$defs ?? {});
+    }
+    if (!isRecord(input)) {
+        return input;
+    }
+    return Object.fromEntries(Object.entries(input).map(([field, child]) => {
+        const wireField = toSnakeCase(field);
+        const property = definition?.properties.find((candidate) => candidate.name === wireField);
+        return [
+            wireField,
+            property?.type === "blob" && isRecord(child)
+                ? Object.fromEntries(Object.entries(child).map(([key, value]) => [toSnakeCase(key), value]))
+                : (action === "link" || action === "unlink") &&
+                    field === "relationship" &&
+                    typeof child === "string"
+                    ? toSnakeCase(child)
+                    : selectToWire(child, property),
+        ];
+    }));
+}
+function isPagedRoute(method, route) {
+    if (route.endsWith("/history")) {
+        return true;
+    }
+    if (method === "POST") {
+        return route.endsWith("/query");
+    }
+    const segments = route.split("/").filter(Boolean);
+    return segments.length === 1;
+}
+function historyEntryFromWire(item) {
+    const { record_id: recordId, action_id: actionId, principal_id: principalId, ...entry } = item;
+    return { ...entry, recordId, actionId, principalId };
+}
+export function responseFromWire(input) {
+    const { method, path, payload } = input;
+    if (!isRecord(payload)) {
+        return payload;
+    }
+    const route = path.split("?")[0] ?? "";
+    if (!isPagedRoute(method, route) || !Object.hasOwn(payload, "next_cursor")) {
+        return payload;
+    }
+    const { next_cursor: nextCursor, ...page } = payload;
+    if (!route.endsWith("/history") || !Array.isArray(page.items)) {
+        return { ...page, nextCursor };
+    }
+    const items = page.items.map(historyEntryFromWire);
+    return { ...page, nextCursor, items };
+}
+/** Decode current edits using the current catalog; stored historical changes retain their names. */
+export function editsFromWire(edits, catalog) {
+    return edits.map((edit) => {
+        const before = recordFromWire(Object.fromEntries(Object.entries(edit.changes).map(([field, change]) => [field, change.before])), edit.entity, catalog);
+        const after = recordFromWire(Object.fromEntries(Object.entries(edit.changes).map(([field, change]) => [field, change.after])), edit.entity, catalog);
+        return {
+            ...edit,
+            entity: toCamelCase(edit.entity),
+            changes: Object.fromEntries(Object.keys(before).map((field) => [
+                field,
+                { before: before[field], after: after[field] },
+            ])),
+        };
+    });
+}