@segmentstream-cloud/ontology 0.6.0 → 0.8.0

package/dist/query.js

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import { wireStruct } from "./wire.js";
 /**
  * The query language of `find` and of the HTTP API's list and query endpoints.
  *
@@ -10,7 +11,7 @@ import { Schema } from "effect";
  *     "tags": { "some": { "name": { "eq": "priority" } } },
  *     "or": [{ "fitScore": { "gte": 80 } }, { "source": "pilot_request" }]
  *   },
- *   "orderBy": [{ "field": "createdAt", "direction": "desc" }],
+ *   "orderBy": [{ "field": "created_at", "direction": "desc" }],
  *   "include": { "owner": true },
  *   "limit": 50
  * }
@@ -72,10 +73,10 @@ export function queryResultSchema(record) {
 }
 const SYSTEM_FIELDS = [
     { name: "id", storage: "uuid", nullable: false },
-    { name: "createdAt", storage: "timestamp", nullable: false },
-    { name: "updatedAt", storage: "timestamp", nullable: false },
-    { name: "createdBy", storage: "uuid", nullable: true },
-    { name: "updatedBy", storage: "uuid", nullable: true },
+    { name: "created_at", storage: "timestamp", nullable: false },
+    { name: "updated_at", storage: "timestamp", nullable: false },
+    { name: "created_by", storage: "uuid", nullable: true },
+    { name: "updated_by", storage: "uuid", nullable: true },
 ];
 /** The fields of an entity's records, in record order. */
 export function queryFields(entity) {
@@ -90,7 +91,7 @@ export function queryFields(entity) {
     const keys = entity.relationships
         .filter((relationship) => relationship.cardinality === "one")
         .map((relationship) => ({
-        name: `${relationship.name}Id`,
+        name: `${relationship.name}_id`,
         storage: "uuid",
         nullable: relationship.optional === true,
     }));
@@ -224,7 +225,7 @@ function isOperatorObject(value) {
     return (typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
-        Object.keys(value).every((key) => FILTER_OPERATORS.includes(key)));
+        Object.keys(value).every((key) => [...FILTER_OPERATORS, "is_null", "starts_with"].includes(key)));
 }
 /** The bare-value form of `eq`. For JSON, an object of operators is a filter, never a value. */
 function shorthandSchema(field, value) {
@@ -233,7 +234,7 @@ function shorthandSchema(field, value) {
     }
     return JsonValue.check(Schema.makeFilter((candidate) => !isOperatorObject(candidate) || "Expected a filter"));
 }
-function fieldFilterSchema(field, identifier) {
+function fieldFilterSchema(field, identifier, wire) {
     const value = fieldValueSchema(field);
     const operators = {
         eq: Schema.optionalKey(value),
@@ -251,24 +252,28 @@ function fieldFilterSchema(field, identifier) {
         }
         operators.between = Schema.optionalKey(Schema.Tuple([value, value]));
     }
-    const filter = closedStruct(operators, "Unknown operator");
-    const note = FILTER_DESCRIPTIONS[identifier];
+    const filter = wire
+        ? wireStruct(operators, { isNull: "is_null", startsWith: "starts_with" })
+        : closedStruct(operators, "Unknown operator");
+    const note = wire
+        ? FILTER_DESCRIPTIONS[identifier]?.replaceAll("startsWith", "starts_with")
+        : FILTER_DESCRIPTIONS[identifier];
     return Schema.Union([filter, shorthandSchema(field, value), Schema.Null]).annotate({
         identifier,
         description: "Conditions on the field, all of which must hold. A bare value means eq, null means " +
-            `isNull: true, and ne also matches empty values.${note === undefined ? "" : ` ${note}`}`,
+            `${wire ? "is_null" : "isNull"}: true, and ne also matches empty values.${note === undefined ? "" : ` ${note}`}`,
     });
 }
-function filterFor(entity, field, schemas) {
+function filterFor(entity, field, schemas, wire) {
     if (field.storage === "select") {
         const identifier = `${pascalCase(entity.name)}${pascalCase(field.name)}Filter`;
-        const existing = schemas.get(identifier) ?? fieldFilterSchema(field, identifier);
+        const existing = schemas.get(identifier) ?? fieldFilterSchema(field, identifier, wire);
         schemas.set(identifier, existing);
         return existing;
     }
     const identifier = FILTER_IDENTIFIERS[field.storage];
-    const existing = sharedFilters.get(identifier) ?? fieldFilterSchema(field, identifier);
-    sharedFilters.set(identifier, existing);
+    const existing = sharedFilters.get(`${identifier}:${wire}`) ?? fieldFilterSchema(field, identifier, wire);
+    sharedFilters.set(`${identifier}:${wire}`, existing);
     return existing;
 }
 /** `pilot_request` → `PilotRequest`, `fitScore` → `FitScore`. */
@@ -282,7 +287,7 @@ function pascalCase(name) {
  * The `where` of an entity. With `links`, it includes the entity's relationships, whose targets are
  * filtered by their own fields only: relationship paths are one level deep.
  */
-function whereSchema(manifest, entity, links, schemas) {
+function whereSchema(manifest, entity, links, schemas, wire) {
     const identifier = `${pascalCase(entity.name)}${links ? "Where" : "FieldsWhere"}`;
     const existing = schemas.get(identifier);
     if (existing !== undefined) {
@@ -299,11 +304,11 @@ function whereSchema(manifest, entity, links, schemas) {
     const fields = {};
     schemas.set(identifier, self);
     for (const field of queryFields(entity)) {
-        fields[field.name] = Schema.optionalKey(filterFor(entity, field, schemas));
+        fields[field.name] = Schema.optionalKey(filterFor(entity, field, schemas, wire));
     }
     if (links) {
         for (const link of queryLinks(manifest, entity.name)) {
-            const target = whereSchema(manifest, requireEntity(manifest, link.target), false, schemas);
+            const target = whereSchema(manifest, requireEntity(manifest, link.target), false, schemas, wire);
             fields[link.name] = Schema.optionalKey(link.cardinality === "one" ? target : manyFilterSchema(link, target));
         }
     }
@@ -322,6 +327,7 @@ function manyFilterSchema(link, target) {
         description: `Whether some, none or every one of the related ${link.target} records match.`,
     });
 }
+const wireQuerySchemas = new WeakMap();
 const querySchemas = new WeakMap();
 /**
  * The precise query schemas of one entity: its fields with the operators of their types, its
@@ -329,8 +335,9 @@ const querySchemas = new WeakMap();
  * include. Every struct is closed: an unknown field, operator or key is an issue whatever the parse
  * options, never a silently ignored filter.
  */
-export function entityQuerySchemas(manifest, entityName) {
-    const cached = querySchemas.get(manifest)?.get(entityName);
+export function entityQuerySchemas(manifest, entityName, wire = false) {
+    const cache = wire ? wireQuerySchemas : querySchemas;
+    const cached = cache.get(manifest)?.get(entityName);
     if (cached !== undefined) {
         return cached;
     }
@@ -341,7 +348,7 @@ export function entityQuerySchemas(manifest, entityName) {
     for (const link of queryLinks(manifest, entityName)) {
         include[link.name] = Schema.optionalKey(Schema.Literal(true));
     }
-    const where = whereSchema(manifest, entity, true, new Map());
+    const where = whereSchema(manifest, entity, true, new Map(), wire);
     const orderBy = Schema.Array(closedStruct({
         field: Schema.Literals(fields.map((field) => field.name)),
         direction: Schema.optionalKey(SortDirection),
@@ -349,13 +356,16 @@ export function entityQuerySchemas(manifest, entityName) {
     const included = closedStruct(include, "Unknown relationship").annotate({
         description: "Related records to add to each record, by relationship name.",
     });
-    const query = closedStruct({
+    const queryMembers = {
         where: Schema.optionalKey(where),
         orderBy: Schema.optionalKey(orderBy),
         include: Schema.optionalKey(included),
         after: Schema.optionalKey(After),
         limit: Schema.optionalKey(Limit),
-    }, "Unknown key; use where, orderBy, include, after or limit").annotate({ identifier: `${pascal}Query`, description: `A query on ${entity.plural}.` });
+    };
+    const query = (wire
+        ? wireStruct(queryMembers, { orderBy: "order_by" })
+        : closedStruct(queryMembers, "Unknown key; use where, orderBy, include, after or limit")).annotate({ identifier: `${pascal}Query`, description: `A query on ${entity.plural}.` });
     // The structs are assembled from the manifest, so their static types are too wide to name; they
     // accept exactly the Query shape and decode it unchanged.
     const schemas = {
@@ -366,9 +376,9 @@ export function entityQuerySchemas(manifest, entityName) {
         after: After,
         query,
     };
-    const byEntity = querySchemas.get(manifest) ?? new Map();
+    const byEntity = cache.get(manifest) ?? new Map();
     byEntity.set(entityName, schemas);
-    querySchemas.set(manifest, byEntity);
+    cache.set(manifest, byEntity);
     return schemas;
 }
 /** The query schema of one entity; see {@link entityQuerySchemas}. */
@@ -411,7 +421,7 @@ function recordValueSchema(field) {
 }
 /**
  * The record of an entity as the runtime returns it: system fields, properties (`null` when empty;
- * dates as `YYYY-MM-DD`, timestamps as ISO 8601 in UTC) and a `<relationship>Id` per `rel.one`. It
+ * dates as `YYYY-MM-DD`, timestamps as ISO 8601 in UTC) and a `<relationship>_id` per `rel.one`. It
  * checks the shape of stored values, not the refinements of the definition (`maxLength`, `min`,
  * patterns), so that tightening a refinement never makes existing records unreadable.
  */
@@ -430,7 +440,7 @@ function recordFields(entity) {
     return fields;
 }
 /** A page of an entity's records, with the relationships a query may include. */
-export function entityQueryResultSchema(manifest, entityName) {
+export function entityQueryResultSchema(manifest, entityName, wire = false) {
     const entity = requireEntity(manifest, entityName);
     const fields = recordFields(entity);
     for (const link of queryLinks(manifest, entityName)) {
@@ -438,7 +448,8 @@ export function entityQueryResultSchema(manifest, entityName) {
         fields[link.name] = Schema.optionalKey(link.cardinality === "one" ? Schema.NullOr(target) : Schema.Array(target));
     }
     const record = Schema.Struct(fields);
-    return queryResultSchema(record);
+    const page = queryResultSchema(record);
+    return wire ? page.pipe(Schema.encodeKeys({ nextCursor: "next_cursor" })) : page;
 }
 /** A JSON Schema whose root is the schema itself, not a `$ref`, as MCP tool inputs need it. */
 function jsonSchema(schema) {
@@ -453,9 +464,9 @@ function jsonSchema(schema) {
 }
 /** The JSON Schema (draft 2020-12) of an entity's queries, for MCP tools, OpenAPI and the console. */
 export function queryJsonSchema(manifest, entityName) {
-    return jsonSchema(entityQuerySchema(manifest, entityName));
+    return jsonSchema(entityQuerySchemas(manifest, entityName, true).query);
 }
 /** The JSON Schema (draft 2020-12) of a page of an entity's records. */
 export function queryResultJsonSchema(manifest, entityName) {
-    return jsonSchema(entityQueryResultSchema(manifest, entityName));
+    return jsonSchema(entityQueryResultSchema(manifest, entityName, true));
 }

package/dist/runtime/cursor.js

@@ -3,7 +3,7 @@ import { fieldValueSchema } from "../query.js";
 import { bindValue } from "./records.js";
 import { columnOf } from "./statement.js";
 /** The default order: newest first. */
-const DEFAULT_ORDER = [{ field: "createdAt", direction: "desc" }];
+const DEFAULT_ORDER = [{ field: "created_at", direction: "desc" }];
 export function sortKeys(entity, orderBy) {
     const requested = orderBy === undefined || orderBy.length === 0 ? DEFAULT_ORDER : orderBy;
     const keys = [];

package/dist/runtime/generated-actions.d.ts

@@ -3,13 +3,13 @@ import type { JsonSchemaObject } from "../analyze.js";
 import type { Ontology } from "../ontology.js";
 /** An entity's generated actions by name. */
 export type GeneratedActions = Readonly<Record<string, AnyAction>>;
-/** `upsertByEmail`. */
+/** `upsert_by_email`. */
 export declare function upsertActionName(property: string): string;
 /**
  * The actions generated for an entity: `create`, `update` (without `managed` properties), `delete`,
- * `upsertBy<Property>` per unique property, and `link`/`unlink` when it declares a `rel.many`. They
+ * `upsert_by_<property>` per unique property, and `link`/`unlink` when it declares a `rel.many`. They
  * are ordinary actions and run through the same pipeline. Their `permission` is unset: each requires
- * the permission named after it (`lead:create`), and `upsertBy<Property>` both `create` and `update`,
+ * the permission named after it (`lead:create`), and `upsert_by_<property>` both `create` and `update`,
  * as `generatedActionPermissions` says. The built-in User has none: members are created by sign-in
  * and services by the app or the CLI.
  */
@@ -18,7 +18,7 @@ export declare function generatedActions(ontology: Ontology, entityName: string)
 export interface GeneratedActionManifest {
     readonly name: string;
     readonly description: string;
-    /** Every permission the action requires: one, or `create` and `update` for `upsertBy<Property>`. */
+    /** Every permission the action requires: one, or `create` and `update` for `upsert_by_<property>`. */
     readonly permissions: ReadonlyArray<string>;
     readonly input: JsonSchemaObject;
 }

package/dist/runtime/generated-actions.js

@@ -5,19 +5,15 @@ import { generatedActionPermissions } from "../permissions.js";
 import { p, REFERENCE_ANNOTATION } from "../property.js";
 import { isCalendarDate, isInstant } from "../query.js";
 import { OntologyWrites } from "../runtime.js";
-import { User } from "../user.js";
 import { entityModel, ontologyModel, propertyValueSchema, } from "./model.js";
 /** Generated actions, built once per ontology and entity. */
 const builtActions = new WeakMap();
 function article(word) {
     return /^[aeiou]/i.test(word) ? `an ${word}` : `a ${word}`;
 }
-function capitalize(name) {
-    return name.charAt(0).toUpperCase() + name.slice(1);
-}
-/** `upsertByEmail`. */
+/** `upsert_by_email`. */
 export function upsertActionName(property) {
-    return `${GENERATED_UPSERT_PREFIX}${capitalize(property)}`;
+    return `${GENERATED_UPSERT_PREFIX}${property}`;
 }
 /** A property's value schema, refusing days that do not exist, which PostgreSQL would reject. */
 function propertyInput(field) {
@@ -83,9 +79,9 @@ function valuesOf(input, omit) {
 }
 /**
  * The actions generated for an entity: `create`, `update` (without `managed` properties), `delete`,
- * `upsertBy<Property>` per unique property, and `link`/`unlink` when it declares a `rel.many`. They
+ * `upsert_by_<property>` per unique property, and `link`/`unlink` when it declares a `rel.many`. They
  * are ordinary actions and run through the same pipeline. Their `permission` is unset: each requires
- * the permission named after it (`lead:create`), and `upsertBy<Property>` both `create` and `update`,
+ * the permission named after it (`lead:create`), and `upsert_by_<property>` both `create` and `update`,
  * as `generatedActionPermissions` says. The built-in User has none: members are created by sign-in
  * and services by the app or the CLI.
  */
@@ -101,7 +97,7 @@ export function generatedActions(ontology, entityName) {
 }
 function buildGeneratedActions(ontology, entityName) {
     const entity = entityModel(ontologyModel(ontology), entityName);
-    if (entity.resolved.entity.definition === User.definition) {
+    if (entity.resolved.builtIn) {
         return {};
     }
     const label = entity.label.toLowerCase();

package/dist/runtime/history.js

@@ -33,7 +33,7 @@ export const HistoryEntry = Schema.Struct({
     at: Schema.String,
     changes: Changes,
 });
-/** The fields history records: declared properties and `<relationship>Id` keys. */
+/** The fields history records: declared properties and `<relationship>_id` keys. */
 function changedFields(entity) {
     return entity.fields.filter((field) => field.source !== "system");
 }

package/dist/runtime/model.d.ts

@@ -12,7 +12,7 @@ export interface FieldModel extends QueryField {
     readonly source: "system" | "property" | "relationship";
     /** The declared property, for properties. */
     readonly property?: ResolvedProperty;
-    /** The relationship whose key the field holds, for `<relationship>Id`. */
+    /** The relationship whose key the field holds, for `<relationship>_id`. */
     readonly relationship?: string;
 }
 /** A declared `rel.one`: this entity's key column points at the target's id. */
@@ -45,7 +45,7 @@ export interface EntityModel {
     readonly historyTable: string;
     readonly resolved: ResolvedEntity;
     readonly manifest: EntityManifest;
-    /** System fields, properties and `<relationship>Id` keys, in record order. */
+    /** System fields, properties and `<relationship>_id` keys, in record order. */
     readonly fields: ReadonlyArray<FieldModel>;
     readonly fieldsByName: ReadonlyMap<string, FieldModel>;
     readonly links: ReadonlyMap<string, LinkModel>;

package/dist/runtime/model.js

@@ -80,7 +80,7 @@ function buildField(entity, field, properties) {
             property,
         };
     }
-    const relationship = field.name.slice(0, -"Id".length);
+    const relationship = field.name.slice(0, -"_id".length);
     return {
         ...field,
         column: relationshipColumnName(relationship),

package/dist/runtime/principals.js

@@ -1,3 +1,4 @@
+import { propertyDefinition } from "../property.js";
 import { pbkdf2, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { promisify } from "node:util";
 import { Effect, Schema } from "effect";
@@ -5,7 +6,7 @@ import { SqlClient } from "effect/unstable/sql";
 import { isSqlError } from "effect/unstable/sql/SqlError";
 import { entity, } from "../entity.js";
 import { API_KEYS_TABLE, USER_ROLES_TABLE, USER_TABLE } from "../migrate/storage.js";
-import { MEMBER_ROLE } from "../names.js";
+import { MEMBER_ROLE, toSnakeCase } from "../names.js";
 import { buildOntology } from "../ontology.js";
 import { permissionsOf } from "../permissions.js";
 import { EMAIL_PATTERN } from "../property.js";
@@ -110,19 +111,19 @@ function userRow(record) {
  * the ontology's sign-in policy decides: `invited` turns the person away, `open` creates a member.
  */
 function signIn(ontology, sql, claims) {
-    const runtime = platformRuntime(ontology, sql, "user.signIn");
+    const runtime = platformRuntime(ontology, sql, "user.sign_in");
     const claimedEmail = claims.email?.trim().toLowerCase();
     const email = claimedEmail !== undefined && EMAIL_PATTERN.test(claimedEmail) ? claimedEmail : undefined;
     return sql
         .withTransaction(Effect.gen(function* () {
         const now = new Date();
-        const signedIn = { lastSignInAt: now.toISOString() };
+        const signedIn = { last_sign_in_at: now.toISOString() };
         const [linked] = yield* runtime.find({
             entity: "user",
             options: {
                 where: {
-                    identityProvider: claims.identityProvider,
-                    identitySubject: claims.identitySubject,
+                    identity_provider: claims.identityProvider,
+                    identity_subject: claims.identitySubject,
                 },
                 limit: 1,
                 forUpdate: true,
@@ -130,7 +131,7 @@ function signIn(ontology, sql, claims) {
         });
         if (linked !== undefined) {
             // An inactive user is turned away, which is not a sign-in to record.
-            if (linked.active !== true || !signInDue(linked.lastSignInAt, now)) {
+            if (linked.active !== true || !signInDue(linked.last_sign_in_at, now)) {
                 return userRow(linked);
             }
             const returning = yield* runtime.update({
@@ -147,7 +148,7 @@ function signIn(ontology, sql, claims) {
                 options: { where: { email }, limit: 1, forUpdate: true },
             });
         if (invited !== undefined) {
-            if (invited.kind !== "member" || invited.identitySubject !== null) {
+            if (invited.kind !== "member" || invited.identity_subject !== null) {
                 return yield* new PrincipalRejected({
                     reason: "identity_conflict",
                     message: "Another user already has this email.",
@@ -157,8 +158,8 @@ function signIn(ontology, sql, claims) {
                 entity: "user",
                 id: invited.id,
                 values: {
-                    identityProvider: claims.identityProvider,
-                    identitySubject: claims.identitySubject,
+                    identity_provider: claims.identityProvider,
+                    identity_subject: claims.identitySubject,
                     ...(invited.active === true ? signedIn : {}),
                 },
             });
@@ -176,8 +177,8 @@ function signIn(ontology, sql, claims) {
                 name: claims.name?.trim() || email || claims.identitySubject,
                 email: email ?? null,
                 kind: "member",
-                identityProvider: claims.identityProvider,
-                identitySubject: claims.identitySubject,
+                identity_provider: claims.identityProvider,
+                identity_subject: claims.identitySubject,
                 ...signedIn,
             },
         });
@@ -295,7 +296,7 @@ export function setUserRoles(ontology, input) {
 export function createServiceUser(ontology, input) {
     return Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
-        const runtime = platformRuntime(ontology, sql, "user.createService");
+        const runtime = platformRuntime(ontology, sql, "user.create_service");
         return yield* sql.withTransaction(Effect.gen(function* () {
             const user = yield* runtime
                 .create({ entity: "user", values: { name: input.name, kind: "service" } })
@@ -317,7 +318,9 @@ function deployedUser(manifest) {
         return User;
     }
     const names = new Set(deployed.properties.map((property) => property.name));
-    const kept = Object.entries(User.definition.properties).filter(([name]) => names.has(name));
+    const kept = Object.entries(User.definition.properties).filter(([name, property]) => names.has(toSnakeCase(name)) ||
+        (propertyDefinition(property)?.renamedFrom !== undefined &&
+            names.has(propertyDefinition(property).renamedFrom)));
     if (kept.length === Object.keys(User.definition.properties).length) {
         return User;
     }

package/dist/runtime/reads.js

@@ -139,7 +139,7 @@ function loadRelated(context, link, records) {
         const target = entityModel(context.model, link.target);
         const params = new Params();
         if (link.via === "key") {
-            const keyField = `${link.name}Id`;
+            const keyField = `${link.name}_id`;
             const ids = [...new Set(records.map((record) => record[keyField]).filter(isString))];
             const byId = new Map();
             if (ids.length > 0) {

package/dist/runtime/records.js

@@ -130,7 +130,7 @@ export function prepareWrite(entity, values, mode) {
                 columns.push({ field, value });
             }
             else if (link?.via === "key") {
-                const key = entity.fieldsByName.get(`${name}Id`);
+                const key = entity.fieldsByName.get(`${name}_id`);
                 if (value === null && !link.optional) {
                     issues.push({ path: [name], message: `${name} is required` });
                 }

package/dist/runtime/sql-runtime.js

@@ -117,7 +117,7 @@ export function makeOntologyRuntime(ontology, sql, scope) {
             }
             const target = entityModel(model, link.target);
             const validated = yield* validateQuery(target, input.query ?? {});
-            const keyValue = link.via === "key" ? (source[`${link.name}Id`] ?? null) : null;
+            const keyValue = link.via === "key" ? (source[`${link.name}_id`] ?? null) : null;
             return yield* orDieOnSql(runQuery(context, target, validated, {
                 condition: relatedCondition(link, source.id, keyValue),
             }));

package/dist/service/config.d.ts

@@ -48,7 +48,7 @@ export interface ActionCommitted {
     readonly entity: string;
     readonly action: string;
     readonly principal: Principal;
-    /** The input as the caller sent it. */
+    /** The decoded input, using the authored TypeScript schema. */
     readonly input: unknown;
     readonly result: unknown;
     readonly edits: ReadonlyArray<unknown>;

package/dist/service/errors.d.ts

@@ -42,6 +42,7 @@ export interface ErrorResponse {
     readonly headers?: Readonly<Record<string, string>>;
 }
 export declare function toServerResponse(response: ErrorResponse): HttpServerResponse.HttpServerResponse;
+export declare function errorBodyForWire(body: ErrorBody): Readonly<Record<string, unknown>>;
 /** Issues of a schema failure, as `[{ path, message }]`. */
 export declare function schemaIssues(issue: SchemaIssue.Issue): Array<ValidationIssue>;
 export declare function unauthorized(requestId: string, detail: string): ErrorResponse;

package/dist/service/errors.js

@@ -21,11 +21,15 @@ export class InvalidRequestBody extends Schema.TaggedError()("InvalidRequestBody
 export class SignInCheckLimited extends Schema.TaggedError()("SignInCheckLimited", { retryAfterSeconds: Schema.Number }) {
 }
 export function toServerResponse(response) {
-    return HttpServerResponse.jsonUnsafe(response.body, {
+    return HttpServerResponse.jsonUnsafe(errorBodyForWire(response.body), {
         status: response.status,
         ...(response.headers !== undefined ? { headers: response.headers } : {}),
     });
 }
+export function errorBodyForWire(body) {
+    const { requestId, ...rest } = body;
+    return { ...rest, request_id: requestId };
+}
 /** Issues of a schema failure, as `[{ path, message }]`. */
 export function schemaIssues(issue) {
     const formatted = SchemaIssue.makeFormatterStandardSchemaV1()(issue);

package/dist/service/handlers.js

@@ -1,6 +1,10 @@
 import { HttpServerResponse } from "effect/unstable/http";
 import { Effect, Layer, Schema } from "effect";
 import { HttpApiBuilder, OpenApi } from "effect/unstable/httpapi";
+import { editsFromWire, generatedResultFromWire, recordFromWire } from "../authoring-records.js";
+import { nameToWire } from "../authoring-names.js";
+import { principalFromWire } from "../authoring.js";
+import { toCamelCase } from "../names.js";
 import { PermissionDenied } from "../errors.js";
 import { missingPermission, permissionOf, READ_VERB } from "../permissions.js";
 import { EMAIL_PATTERN } from "../property.js";
@@ -84,7 +88,7 @@ function requireRead(entities) {
 }
 /**
  * Follows a relationship from one record with the query language: the record's own
- * `<relationship>Id` for a `rel.one`, and for everything to-many a relationship path from the
+ * `<relationship>_id` for a `rel.one`, and for everything to-many a relationship path from the
  * target back to the record (`lead.notes` is notes whose `lead` is the lead, `lead.tags` is tags
  * some of whose `leads` is the lead), combined with the caller's query and paged like any find.
  */
@@ -96,7 +100,7 @@ function traverse(planned, traversal, request, targets) {
         yield* requireRead([planned.name, ...queryReads(traversal.target, query, targets)]);
         const source = yield* backend.get({ entity: planned.name, id });
         if (traversal.kind === "one") {
-            const targetId = source[`${traversal.name}Id`];
+            const targetId = source[`${traversal.name}_id`];
             if (typeof targetId !== "string") {
                 return { items: [], nextCursor: null };
             }
@@ -141,26 +145,31 @@ function readEnvelope(request) {
  * The configured hook as `runAction` runs it after the commit. A failure is logged with the request
  * id here, so the action's caller still gets the committed result.
  */
-function afterCommitOf(hook, request) {
-    return (committed) => Effect.tryPromise(async () => hook({
-        entity: committed.entity,
-        action: committed.action,
-        principal: committed.principal,
-        input: request.input,
-        result: committed.result,
-        edits: committed.edits,
-        requestId: request.requestId,
-    })).pipe(Effect.catchCause((cause) => Effect.logError("ontology.after_commit.failed", cause).pipe(Effect.annotateLogs({
-        requestId: request.requestId,
-        action: `${committed.entity}.${committed.action}`,
-    }))));
+function afterCommitOf(hook, request, ontology) {
+    return (committed) => {
+        const definition = ontology.config.entities.find((entity) => nameToWire(entity.name) === committed.entity)?.definition;
+        return Effect.tryPromise(async () => hook({
+            entity: toCamelCase(committed.entity),
+            action: toCamelCase(committed.action),
+            principal: principalFromWire(committed.principal),
+            input: request.generated ? recordFromWire(committed.input, definition) : committed.input,
+            result: request.generated
+                ? generatedResultFromWire(committed.result, committed.action, definition)
+                : committed.result,
+            edits: editsFromWire(committed.edits, ontology.config.entities),
+            requestId: request.requestId,
+        })).pipe(Effect.catchCause((cause) => Effect.logError("ontology.after_commit.failed", cause).pipe(Effect.annotateLogs({
+            requestId: request.requestId,
+            action: `${committed.entity}.${committed.action}`,
+        }))));
+    };
 }
 /** The deployment's OIDC token: Vercel sets it on each request, and in the environment of builds. */
 function identityToken(request) {
     const header = request.headers[OIDC_TOKEN_HEADER];
     return typeof header === "string" && header !== "" ? header : process.env.VERCEL_OIDC_TOKEN;
 }
-function runAction(planned, { name }, hook, connections) {
+function runAction(planned, { name, generated }, ontology, hook, connections) {
     return ({ request }) => Effect.gen(function* () {
         const backend = yield* OntologyBackend;
         const principal = yield* CurrentPrincipal;
@@ -180,7 +189,7 @@ function runAction(planned, { name }, hook, connections) {
             }),
             ...(hook === undefined
                 ? {}
-                : { afterCommit: afterCommitOf(hook, { input: envelope.input, requestId }) }),
+                : { afterCommit: afterCommitOf(hook, { requestId, generated }, ontology) }),
         });
         const { issues } = outcome.validation;
         if (!outcome.validation.ok && !validateOnly) {
@@ -214,7 +223,7 @@ function entityHandlers(built, planned, hooks, targets, connections) {
             registered = registered.handle(`related.${traversal.name}`, (request) => traverse(planned, traversal, request, targets).pipe(Effect.provideService(OntologyBackend, backend)));
         }
         for (const action of planned.actions) {
-            const handler = runAction(planned, action, hooks.get(`${planned.name}.${action.name}`), connections);
+            const handler = runAction(planned, action, built.plan.ontology, hooks.get(`${planned.name}.${action.name}`), connections);
             registered = registered.handleRaw(`actions.${action.name}`, (request) => handler(request).pipe(Effect.provideService(OntologyBackend, backend)));
         }
         return registered;

package/dist/service/runtime-contract.d.ts

@@ -35,7 +35,7 @@ export interface RunActionInput {
     readonly connections?: ConnectionTransport["Service"];
 }
 /**
- * `generatedActions(entity, ontology)`: `create`, `update`, `delete`, `upsertBy<Property>`, `link`
+ * `generatedActions(entity, ontology)`: `create`, `update`, `delete`, `upsert_by_<property>`, `link`
  * and `unlink`, as `src/runtime/generated-actions.ts` derives them.
  */
 export type GeneratedActionsProvider = (entity: ResolvedEntity, ontology: Ontology) => Readonly<Record<string, AnyAction>>;