@segmentstream-cloud/ontology 0.6.0 → 0.7.0

package/dist/service/schemas.d.ts

@@ -4,14 +4,14 @@ import type { ApiPlan } from "./plan.js";
 export declare const IdParam: Schema.String;
 /** The schemas of one entity's records and queries. */
 export interface EntitySchemas {
-    /** System fields, properties and `<relationship>Id` per `rel.one`. */
+    /** System fields, properties and `<relationship>_id` per `rel.one`. */
     readonly record: Schema.Top;
     /** A record with the relationships a query may include. */
     readonly result: Schema.Top;
     /** `POST /<entity>/query`: the entity's query from `src/query.ts`. */
     readonly query: Schema.Top;
     /** `GET /<entity>` and to-many traversals: the query as URL parameters. */
-    readonly queryParams: Schema.Struct.Fields;
+    readonly queryParams: Schema.Top;
     /** `GET /<entity>/{id}/<rel.one>`. */
     readonly includeParams: Schema.Struct.Fields;
     readonly findResult: Schema.Top;
@@ -37,7 +37,7 @@ export declare const Validation: Schema.Struct<{
         readonly message: Schema.String;
     }>>;
 }>;
-export declare const HistoryEntry: Schema.Struct<{
+export declare const HistoryEntry: Schema.decodeTo<Schema.Struct<{
     readonly id: Schema.String;
     readonly recordId: Schema.String;
     readonly action: Schema.String;
@@ -49,9 +49,21 @@ export declare const HistoryEntry: Schema.Struct<{
         readonly before: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
     }>>;
-}>;
-export declare const HistoryPage: Schema.Struct<{
-    readonly items: Schema.$Array<Schema.Struct<{
+}>, Schema.Struct<{
+    readonly id: Schema.toEncoded<Schema.String>;
+    readonly record_id: Schema.toEncoded<Schema.String>;
+    readonly action: Schema.toEncoded<Schema.String>;
+    readonly action_id: Schema.toEncoded<Schema.String>;
+    readonly kind: Schema.toEncoded<Schema.Literals<readonly ["create", "update", "delete", "link", "unlink"]>>;
+    readonly principal_id: Schema.toEncoded<Schema.NullOr<Schema.String>>;
+    readonly at: Schema.toEncoded<Schema.String>;
+    readonly changes: Schema.toEncoded<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly before: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>>;
+}>, never, never>;
+export declare const HistoryPage: Schema.decodeTo<Schema.Struct<{
+    readonly items: Schema.$Array<Schema.decodeTo<Schema.Struct<{
         readonly id: Schema.String;
         readonly recordId: Schema.String;
         readonly action: Schema.String;
@@ -63,9 +75,48 @@ export declare const HistoryPage: Schema.Struct<{
             readonly before: Schema.Codec<Schema.Json, Schema.Json, never, never>;
             readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         }>>;
-    }>>;
+    }>, Schema.Struct<{
+        readonly id: Schema.toEncoded<Schema.String>;
+        readonly record_id: Schema.toEncoded<Schema.String>;
+        readonly action: Schema.toEncoded<Schema.String>;
+        readonly action_id: Schema.toEncoded<Schema.String>;
+        readonly kind: Schema.toEncoded<Schema.Literals<readonly ["create", "update", "delete", "link", "unlink"]>>;
+        readonly principal_id: Schema.toEncoded<Schema.NullOr<Schema.String>>;
+        readonly at: Schema.toEncoded<Schema.String>;
+        readonly changes: Schema.toEncoded<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly before: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>;
+    }>, never, never>>;
     readonly nextCursor: Schema.NullOr<Schema.String>;
-}>;
+}>, Schema.Struct<{
+    readonly items: Schema.toEncoded<Schema.$Array<Schema.decodeTo<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly recordId: Schema.String;
+        readonly action: Schema.String;
+        readonly actionId: Schema.String;
+        readonly kind: Schema.Literals<readonly ["create", "update", "delete", "link", "unlink"]>;
+        readonly principalId: Schema.NullOr<Schema.String>;
+        readonly at: Schema.String;
+        readonly changes: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly before: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly id: Schema.toEncoded<Schema.String>;
+        readonly record_id: Schema.toEncoded<Schema.String>;
+        readonly action: Schema.toEncoded<Schema.String>;
+        readonly action_id: Schema.toEncoded<Schema.String>;
+        readonly kind: Schema.toEncoded<Schema.Literals<readonly ["create", "update", "delete", "link", "unlink"]>>;
+        readonly principal_id: Schema.toEncoded<Schema.NullOr<Schema.String>>;
+        readonly at: Schema.toEncoded<Schema.String>;
+        readonly changes: Schema.toEncoded<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly before: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly after: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>;
+    }>, never, never>>>;
+    readonly next_cursor: Schema.toEncoded<Schema.NullOr<Schema.String>>;
+}>, never, never>;
 /** The body of `POST /<entity>/actions/<action>`, as documented. */
 export declare function actionRequest(input: Schema.Top): Schema.Top;
 /** The body of `POST /<entity>/actions/<action>`, as decoded: `runAction` validates the input. */
@@ -94,10 +145,52 @@ export declare const ActionResponse: Schema.Struct<{
         }>>;
     }>>;
 }>;
-export declare const Catalog: Schema.Struct<{
-    readonly version: Schema.Int;
-    readonly hash: Schema.String;
-    readonly entities: Schema.$Array<Schema.Struct<{
+export declare const Catalog: Schema.decodeTo<Schema.Struct<{
+    readonly entities: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+        readonly properties: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+            readonly column: Schema.optionalKey<Schema.String>;
+            readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly name: Schema.String;
+            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+            readonly label: Schema.String;
+            readonly description: Schema.optionalKey<Schema.String>;
+            readonly optional: Schema.Boolean;
+            readonly unique: Schema.Boolean;
+            readonly managed: Schema.Boolean;
+            readonly default: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly display: Schema.optionalKey<Schema.String>;
+            readonly renamedFrom: Schema.optionalKey<Schema.String>;
+            readonly min: Schema.optionalKey<Schema.Number>;
+            readonly max: Schema.optionalKey<Schema.Number>;
+            readonly maxLength: Schema.optionalKey<Schema.Number>;
+            readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly value: Schema.String;
+                readonly label: Schema.String;
+                readonly description: Schema.String;
+            }>>>;
+        }>, {
+            readonly renamedFrom: "renamed_from";
+            readonly maxLength: "max_length";
+        }>>;
+        readonly relationships: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+            readonly on: Schema.optionalKey<Schema.encodeKeys<Schema.Struct<{
+                readonly property: Schema.String;
+                readonly targetProperty: Schema.String;
+            }>, {
+                readonly targetProperty: "target_property";
+            }>>;
+            readonly onDelete: Schema.optionalKey<Schema.decodeTo<Schema.Literals<readonly ["setNull", "cascade", "restrict"]>, Schema.Literals<readonly ["set_null", "cascade", "restrict"]>, never, never>>;
+            readonly name: Schema.String;
+            readonly to: Schema.String;
+            readonly inverse: Schema.String;
+            readonly cardinality: Schema.Literals<readonly ["one", "many"]>;
+            readonly optional: Schema.optionalKey<Schema.Boolean>;
+            readonly ordered: Schema.optionalKey<Schema.Boolean>;
+            readonly phrase: Schema.Tuple<readonly [Schema.String, Schema.String]>;
+            readonly description: Schema.String;
+        }>, {
+            readonly onDelete: "on_delete";
+        }>>;
         readonly source: Schema.optionalKey<Schema.Struct<{
             readonly asset: Schema.String;
             readonly key: Schema.$Array<Schema.String>;
@@ -120,7 +213,49 @@ export declare const Catalog: Schema.Struct<{
         readonly builtIn: Schema.Boolean;
         readonly renamedFrom: Schema.optionalKey<Schema.String>;
         readonly guide: Schema.optionalKey<Schema.String>;
-        readonly properties: Schema.$Array<Schema.Struct<{
+        readonly indexes: Schema.$Array<Schema.Struct<{
+            readonly properties: Schema.$Array<Schema.String>;
+            readonly unique: Schema.Boolean;
+        }>>;
+        readonly actions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly permission: Schema.optionalKey<Schema.String>;
+            readonly input: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly connections: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>>;
+        readonly permissions: Schema.optionalKey<Schema.Struct<{
+            readonly read: Schema.String;
+            readonly create: Schema.optionalKey<Schema.String>;
+            readonly update: Schema.optionalKey<Schema.String>;
+            readonly delete: Schema.optionalKey<Schema.String>;
+            readonly link: Schema.optionalKey<Schema.String>;
+            readonly unlink: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>, {
+        readonly builtIn: "built_in";
+        readonly renamedFrom: "renamed_from";
+    }>>;
+    readonly roles: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly builtIn: Schema.Boolean;
+        readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, {
+        readonly builtIn: "built_in";
+    }>>;
+    readonly version: Schema.Int;
+    readonly hash: Schema.String;
+    readonly signIn: Schema.optionalKey<Schema.Struct<{
+        readonly policy: Schema.String;
+    }>>;
+    readonly connections: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly description: Schema.String;
+    }>>>;
+}>, Schema.Struct<{
+    readonly entities: Schema.toEncoded<Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+        readonly properties: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
             readonly column: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
             readonly name: Schema.String;
@@ -141,22 +276,51 @@ export declare const Catalog: Schema.Struct<{
                 readonly label: Schema.String;
                 readonly description: Schema.String;
             }>>>;
+        }>, {
+            readonly renamedFrom: "renamed_from";
+            readonly maxLength: "max_length";
         }>>;
-        readonly relationships: Schema.$Array<Schema.Struct<{
-            readonly on: Schema.optionalKey<Schema.Struct<{
+        readonly relationships: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
+            readonly on: Schema.optionalKey<Schema.encodeKeys<Schema.Struct<{
                 readonly property: Schema.String;
                 readonly targetProperty: Schema.String;
+            }>, {
+                readonly targetProperty: "target_property";
             }>>;
+            readonly onDelete: Schema.optionalKey<Schema.decodeTo<Schema.Literals<readonly ["setNull", "cascade", "restrict"]>, Schema.Literals<readonly ["set_null", "cascade", "restrict"]>, never, never>>;
             readonly name: Schema.String;
             readonly to: Schema.String;
             readonly inverse: Schema.String;
             readonly cardinality: Schema.Literals<readonly ["one", "many"]>;
             readonly optional: Schema.optionalKey<Schema.Boolean>;
-            readonly onDelete: Schema.optionalKey<Schema.Literals<readonly ["setNull", "cascade", "restrict"]>>;
             readonly ordered: Schema.optionalKey<Schema.Boolean>;
             readonly phrase: Schema.Tuple<readonly [Schema.String, Schema.String]>;
             readonly description: Schema.String;
+        }>, {
+            readonly onDelete: "on_delete";
         }>>;
+        readonly source: Schema.optionalKey<Schema.Struct<{
+            readonly asset: Schema.String;
+            readonly key: Schema.$Array<Schema.String>;
+            readonly currency: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly measures: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+            readonly unit: Schema.Literals<readonly ["number", "currency", "ratio", "percent"]>;
+            readonly format: Schema.Literals<readonly ["decimal", "currency", "percent"]>;
+            readonly expression: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly label: Schema.String;
+        readonly plural: Schema.String;
+        readonly title: Schema.String;
+        readonly description: Schema.String;
+        readonly builtIn: Schema.Boolean;
+        readonly renamedFrom: Schema.optionalKey<Schema.String>;
+        readonly guide: Schema.optionalKey<Schema.String>;
         readonly indexes: Schema.$Array<Schema.Struct<{
             readonly properties: Schema.$Array<Schema.String>;
             readonly unique: Schema.Boolean;
@@ -176,21 +340,28 @@ export declare const Catalog: Schema.Struct<{
             readonly link: Schema.optionalKey<Schema.String>;
             readonly unlink: Schema.optionalKey<Schema.String>;
         }>>;
-    }>>;
-    readonly roles: Schema.$Array<Schema.Struct<{
+    }>, {
+        readonly builtIn: "built_in";
+        readonly renamedFrom: "renamed_from";
+    }>>>;
+    readonly roles: Schema.toEncoded<Schema.$Array<Schema.encodeKeys<Schema.Struct<{
         readonly name: Schema.String;
         readonly description: Schema.String;
         readonly builtIn: Schema.Boolean;
         readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    }>>;
-    readonly signIn: Schema.optionalKey<Schema.Struct<{
+    }>, {
+        readonly builtIn: "built_in";
+    }>>>;
+    readonly version: Schema.toEncoded<Schema.Int>;
+    readonly hash: Schema.toEncoded<Schema.String>;
+    readonly sign_in: Schema.toEncoded<Schema.optionalKey<Schema.Struct<{
         readonly policy: Schema.String;
-    }>>;
-    readonly connections: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    }>>>;
+    readonly connections: Schema.toEncoded<Schema.optionalKey<Schema.$Array<Schema.Struct<{
         readonly key: Schema.String;
         readonly description: Schema.String;
-    }>>>;
-}>;
+    }>>>>;
+}>, never, never>;
 export declare const Graph: Schema.Struct<{
     readonly hash: Schema.String;
     readonly entities: Schema.$Array<Schema.Struct<{
@@ -212,11 +383,15 @@ export declare const Graph: Schema.Struct<{
         readonly description: Schema.String;
     }>>;
 }>;
-export declare const Status: Schema.Struct<{
+export declare const Status: Schema.decodeTo<Schema.Struct<{
     readonly hash: Schema.String;
     readonly appliedHash: Schema.NullOr<Schema.String>;
     readonly upToDate: Schema.Boolean;
-}>;
+}>, Schema.Struct<{
+    readonly hash: Schema.toEncoded<Schema.String>;
+    readonly applied_hash: Schema.toEncoded<Schema.NullOr<Schema.String>>;
+    readonly up_to_date: Schema.toEncoded<Schema.Boolean>;
+}>, never, never>;
 /** The longest address `POST /api/ontology/sign-in/check` reads; RFC 5321 allows 254. */
 export declare const SIGN_IN_CHECK_MAX_EMAIL_LENGTH = 320;
 /** `POST /api/ontology/sign-in/check`: the address a person wants to sign in with. */

package/dist/service/schemas.js

@@ -1,5 +1,6 @@
 import { Schema, SchemaTransformation } from "effect";
-import { OntologyManifest } from "../manifest.js";
+import { wireStruct } from "../wire.js";
+import { OntologyManifestWire } from "../manifest.js";
 import { entityQuerySchemas, queryLinks } from "../query.js";
 import { ValidationIssue as RuntimeValidationIssue } from "../runtime/errors.js";
 import { Edit, HistoryEntry as RuntimeHistoryEntry } from "../runtime/history.js";
@@ -78,12 +79,12 @@ function recordFields(entity) {
     }
     const fields = {
         id: Id.annotate({ description: "The record's id." }),
-        createdAt: Timestamp,
-        updatedAt: Timestamp,
-        createdBy: Schema.NullOr(Id).annotate({
+        created_at: Timestamp,
+        updated_at: Timestamp,
+        created_by: Schema.NullOr(Id).annotate({
             description: "The user who created the record; null when the platform wrote it.",
         }),
-        updatedBy: Schema.NullOr(Id).annotate({
+        updated_by: Schema.NullOr(Id).annotate({
             description: "The user who last updated the record; null when the platform wrote it.",
         }),
     };
@@ -94,7 +95,7 @@ function recordFields(entity) {
     for (const { name, relationship } of entity.relationships) {
         if (relationship.cardinality === "one") {
             const key = Id.annotate({ description: relationship.description });
-            fields[`${name}Id`] = relationship.optional ? Schema.NullOr(key) : key;
+            fields[`${name}_id`] = relationship.optional ? Schema.NullOr(key) : key;
         }
     }
     return fields;
@@ -105,11 +106,11 @@ function splitList(value) {
         .map((part) => part.trim())
         .filter((part) => part.length > 0);
 }
-/** `createdAt:desc,email` as URL parameter, `[{ field, direction }]` once decoded. */
+/** `created_at:desc,email` as URL parameter, `[{ field, direction }]` once decoded. */
 function orderByParam(orderBy) {
     // URL parameters are documented by their encoded side, so the description goes on the string.
     const encoded = Schema.String.annotate({
-        description: "Comma-separated fields, each optionally followed by :asc or :desc, as in createdAt:desc,email.",
+        description: "Comma-separated fields, each optionally followed by :asc or :desc, as in created_at:desc,email.",
     });
     return encoded.pipe(Schema.decodeTo(orderBy, SchemaTransformation.transform({
         decode: (value) => splitList(value).map((part) => {
@@ -164,7 +165,7 @@ function schemasOf(plan, planned, recordOf) {
     const { manifest } = plan.ontology;
     const pascal = pascalCase(name);
     const record = recordOf(name);
-    const query = entityQuerySchemas(manifest, name);
+    const query = entityQuerySchemas(manifest, name, true);
     const links = queryLinks(manifest, name);
     const includedFields = {};
     for (const link of links) {
@@ -181,13 +182,13 @@ function schemasOf(plan, planned, recordOf) {
         record,
         result,
         query: query.query,
-        queryParams: {
+        queryParams: wireStruct({
             where: Schema.optionalKey(whereParam(query.where)),
             orderBy: Schema.optionalKey(orderByParam(query.orderBy)),
             include: Schema.optionalKey(includeParam(query.include)),
             after: Schema.optionalKey(query.after),
             limit: Schema.optionalKey(query.limit),
-        },
+        }, { orderBy: "order_by" }),
         includeParams: {
             include: Schema.optionalKey(includeParam(query.include)),
         },
@@ -196,7 +197,9 @@ function schemasOf(plan, planned, recordOf) {
             nextCursor: Schema.NullOr(Schema.String).annotate({
                 description: "Pass as after to read the next page; null on the last page.",
             }),
-        }).annotate({ identifier: `${pascal}Page` }),
+        })
+            .pipe(Schema.encodeKeys({ nextCursor: "next_cursor" }))
+            .annotate({ identifier: `${pascal}Page` }),
     };
 }
 const HistoryLimit = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 200 })).annotate({
@@ -204,7 +207,7 @@ const HistoryLimit = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 20
 });
 /** The query parameters of a record's history. */
 export const HistoryParams = {
-    after: Schema.optionalKey(Schema.String.annotate({ description: "The nextCursor of the previous page." })),
+    after: Schema.optionalKey(Schema.String.annotate({ description: "The next_cursor of the previous page." })),
     limit: Schema.optionalKey(HistoryLimit),
 };
 export const ValidationIssue = RuntimeValidationIssue.annotate({ identifier: "ValidationIssue" });
@@ -212,7 +215,7 @@ export const Validation = Schema.Struct({
     ok: Schema.Boolean,
     issues: Schema.Array(ValidationIssue),
 }).annotate({ identifier: "Validation" });
-export const HistoryEntry = RuntimeHistoryEntry.annotate({
+export const HistoryEntry = RuntimeHistoryEntry.pipe(Schema.encodeKeys({ recordId: "record_id", actionId: "action_id", principalId: "principal_id" })).annotate({
     identifier: "HistoryEntry",
     description: "What one action changed on the record: the previous and new value of each property, " +
         "relationship key or link.",
@@ -220,12 +223,14 @@ export const HistoryEntry = RuntimeHistoryEntry.annotate({
 export const HistoryPage = Schema.Struct({
     items: Schema.Array(HistoryEntry),
     nextCursor: Schema.NullOr(Schema.String),
-}).annotate({ identifier: "HistoryPage" });
-const ActionOptions = Schema.Struct({
+})
+    .pipe(Schema.encodeKeys({ nextCursor: "next_cursor" }))
+    .annotate({ identifier: "HistoryPage" });
+const ActionOptions = wireStruct({
     validateOnly: Schema.optionalKey(Schema.Boolean.annotate({
         description: "Validate the input and report issues without a write.",
     })),
-});
+}, { validateOnly: "validate_only" });
 /** The body of `POST /<entity>/actions/<action>`, as documented. */
 export function actionRequest(input) {
     return Schema.Struct({ input, options: Schema.optionalKey(ActionOptions) });
@@ -233,7 +238,7 @@ export function actionRequest(input) {
 /** The body of `POST /<entity>/actions/<action>`, as decoded: `runAction` validates the input. */
 export const ActionEnvelope = closedStruct({
     input: Schema.Unknown,
-    options: Schema.optionalKey(closedStruct({ validateOnly: Schema.optionalKey(Schema.Boolean) }, "Unknown option; use validateOnly")),
+    options: Schema.optionalKey(wireStruct({ validateOnly: Schema.optionalKey(Schema.Boolean) }, { validateOnly: "validate_only" })),
 }, "Unknown key; use input and options");
 export const ActionResponse = Schema.Struct({
     result: Schema.Unknown.annotate({ description: "What the action returned." }),
@@ -242,7 +247,7 @@ export const ActionResponse = Schema.Struct({
         description: "The records the action changed, as their history records each change.",
     }),
 }).annotate({ identifier: "ActionResponse" });
-export const Catalog = OntologyManifest.annotate({ identifier: "Catalog" });
+export const Catalog = OntologyManifestWire.annotate({ identifier: "Catalog" });
 const GraphEntity = Schema.Struct({
     name: Schema.String,
     label: Schema.String,
@@ -272,7 +277,9 @@ export const Status = Schema.Struct({
         description: "The manifest hash recorded by the last migration of the workspace database.",
     }),
     upToDate: Schema.Boolean.annotate({ description: "Whether the two hashes match." }),
-}).annotate({ identifier: "Status" });
+})
+    .pipe(Schema.encodeKeys({ appliedHash: "applied_hash", upToDate: "up_to_date" }))
+    .annotate({ identifier: "Status" });
 /** The longest address `POST /api/ontology/sign-in/check` reads; RFC 5321 allows 254. */
 export const SIGN_IN_CHECK_MAX_EMAIL_LENGTH = 320;
 /** `POST /api/ontology/sign-in/check`: the address a person wants to sign in with. */
@@ -321,7 +328,9 @@ function errorBody(identifier, status, codes, extra = {}) {
         detail: Schema.String,
         requestId: Schema.String.annotate({ description: "Quote it when reporting a problem." }),
         ...extra,
-    }).annotate({ identifier, httpApiStatus: status });
+    })
+        .pipe(Schema.encodeKeys({ requestId: "request_id" }))
+        .annotate({ identifier, httpApiStatus: status });
 }
 export const ErrorSchemas = {
     invalidRequest: errorBody("InvalidRequest", 400, ["invalid_request", "invalid_json"], {

package/dist/service/service.js

@@ -5,7 +5,7 @@ import { sqlServiceRuntime } from "../runtime/service-binding.js";
 import { ErrorResponsesLive, buildApi } from "./api.js";
 import { authenticationLayer, tokenVerifier } from "./authentication.js";
 import { OntologyServiceConfigError, } from "./config.js";
-import { RequestId, failureResponse, internalError, routeNotFound, toServerResponse, } from "./errors.js";
+import { RequestId, failureResponse, internalError, errorBodyForWire, routeNotFound, toServerResponse, } from "./errors.js";
 import { deployedConnections, localConnections } from "./connections.js";
 import { handlersLayer } from "./handlers.js";
 import { planApi } from "./plan.js";
@@ -77,7 +77,7 @@ export function createOntologyService(ontology, config) {
                 // The runtime could not be built or the router itself failed: log everything, answer little.
                 console.error("ontology.request.failed", { requestId, error });
                 const failure = internalError(requestId);
-                response = Response.json(failure.body, { status: failure.status });
+                response = Response.json(errorBodyForWire(failure.body), { status: failure.status });
             }
             return decorate(response, requestId, hash);
         },

package/dist/user.d.ts

@@ -13,8 +13,8 @@ export declare const User: import("./entity.js").DraftEntity<"user", {
     readonly email: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, true>>;
     readonly kind: import("./property.js").Property<"member" | "service", false, false>;
     readonly active: import("./property.js").Property<boolean, true, false>;
-    readonly identityProvider: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, false>>;
-    readonly identitySubject: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, false>>;
-    readonly lastSignInAt: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, false>>;
+    readonly identity_provider: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, false>>;
+    readonly identity_subject: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, false>>;
+    readonly last_sign_in_at: import("effect/Schema").optionalKey<import("./property.js").Property<string, false, false>>;
 }, import("./entity.js").Relationships>;
 export type User = typeof User.Type;

package/dist/user.js

@@ -41,24 +41,27 @@ export const User = entity("user", {
             managed: true,
             description: "Inactive users cannot sign in or run actions.",
         }),
-        identityProvider: p.text({
+        identity_provider: p.text({
+            renamedFrom: "identityProvider",
             optional: true,
             managed: true,
             description: "Who signs the member in, for example neon-auth. Empty for services.",
         }),
-        identitySubject: p.text({
+        identity_subject: p.text({
+            renamedFrom: "identitySubject",
             optional: true,
             managed: true,
             description: "The member's id at the identity provider: the subject of their token.",
         }),
         // Optional so that a table created before it gains the column without a backfill: a member
         // who has not signed in since simply has none.
-        lastSignInAt: p.timestamp({
+        last_sign_in_at: p.timestamp({
+            renamedFrom: "lastSignInAt",
             optional: true,
             managed: true,
             label: "Last sign-in",
             description: "When the member last signed in to the app. Empty until they do.",
         }),
     },
-    indexes: [{ properties: ["identityProvider", "identitySubject"], unique: true }],
+    indexes: [{ properties: ["identity_provider", "identity_subject"], unique: true }],
 });

package/dist/warehouse-backed.js

@@ -1,4 +1,4 @@
-import { CAMEL_CASE_NAME } from "./names.js";
+import { SNAKE_CASE_NAME } from "./names.js";
 const columnName = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const types = new Set(["text", "integer", "number", "boolean", "date", "timestamp", "select"]);
 /** Cross-field validation runs after relationships have resolved their target entities. */
@@ -73,11 +73,11 @@ export function checkWarehouseSource(entities, report) {
             }
             for (const [name, measure] of Object.entries(measures)) {
                 const field = `${path}.measures.${name}`;
-                if (!CAMEL_CASE_NAME.test(name) ||
+                if (!SNAKE_CASE_NAME.test(name) ||
                     properties.has(name) ||
                     entity.relationships.some((r) => r.name === name) ||
                     !measure.description?.trim()) {
-                    report("invalid-measure", field, "Measures require unique camelCase names and a description.");
+                    report("invalid-measure", field, "Measures require unique snake_case names and a description.");
                 }
                 if (measure.unit !== undefined &&
                     !["number", "currency", "ratio", "percent"].includes(measure.unit)) {

package/dist/wire.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+/** A closed wire object with explicit key mappings and an unchanged decoded TypeScript shape. */
+export declare function wireStruct<const F extends Schema.Struct.Fields, const M extends {
+    readonly [K in keyof F]?: string;
+}>(fields: F, mapping: M): Schema.encodeKeys<Schema.Struct<F>, M>;

package/dist/wire.js

@@ -0,0 +1,21 @@
+import { Schema, SchemaTransformation } from "effect";
+/** A closed wire object with explicit key mappings and an unchanged decoded TypeScript shape. */
+export function wireStruct(fields, mapping) {
+    const codec = Schema.Struct(fields).pipe(Schema.encodeKeys(mapping));
+    const encodedFields = Object.fromEntries(Object.entries(fields).map(([key, field]) => [
+        mapping[key] ?? key,
+        field,
+    ]));
+    const names = Object.keys(encodedFields).join("|");
+    const unknown = Schema.String.check(Schema.isPattern(new RegExp(`^(?!(?:${names})$)`)));
+    const reverse = Object.fromEntries(Object.entries(mapping).map(([key, value]) => [value, key]));
+    const rename = (value, keys) => Object.fromEntries(Object.entries(value).map(([key, child]) => [keys[key] ?? key, child]));
+    const encoded = Schema.StructWithRest(Schema.Struct(encodedFields), [
+        Schema.Record(unknown, Schema.Never.annotate({ message: "Unknown wire key" })),
+    ]);
+    const decoded = Schema.toType(codec);
+    return encoded.pipe(Schema.decodeTo(decoded, SchemaTransformation.transform({
+        decode: (value) => rename(value, reverse),
+        encode: (value) => rename(value, mapping),
+    })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream-cloud/ontology",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Define a SegmentStream workspace app's ontology: entities, relationships, roles and actions, written with Effect.",
   "license": "Apache-2.0",
   "author": "SegmentStream",