@segmentstream-cloud/ontology 0.6.0 → 0.8.0

package/dist/authoring.js

@@ -0,0 +1,237 @@
+import { Schema } from "effect";
+import { isAction } from "./action.js";
+import { actionInputToWire } from "./authoring-input.js";
+import { isRecord, nameToWire, permissionToWire } from "./authoring-names.js";
+import { isEntity } from "./entity.js";
+import { toCamelCase } from "./names.js";
+import { p, propertyDefinition } from "./property.js";
+import { isRelationship } from "./relationship.js";
+import { isRole, member } from "./role.js";
+export function principalFromWire(principal) {
+    return {
+        ...principal,
+        roles: principal.roles.map(toCamelCase),
+        permissions: principal.permissions.map(toCamelCase),
+    };
+}
+function indexToWire(index) {
+    if (Array.isArray(index)) {
+        return index.map(nameToWire);
+    }
+    const definition = index;
+    return { ...definition, properties: (definition.properties ?? []).map(nameToWire) };
+}
+function expressionToWire(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const expression = { ...value };
+    if (typeof value.name === "string" && (value.op === "measure" || value.op === "column")) {
+        expression.name = nameToWire(value.name);
+    }
+    if (Array.isArray(value.args)) {
+        expression.args = value.args.map(expressionToWire);
+    }
+    return expression;
+}
+/** Preserve shared definitions and lazy relationship targets while building the canonical model. */
+class AuthoringEncoder {
+    report;
+    entities = new WeakMap();
+    definitions = new WeakMap();
+    properties = new WeakMap();
+    roles = new WeakMap();
+    constructor(report) {
+        this.report = report;
+    }
+    name(name, path) {
+        const encoded = nameToWire(name);
+        if (typeof name === "string" &&
+            /^[a-z][a-zA-Z0-9]*$/.test(name) &&
+            name !== toCamelCase(encoded)) {
+            this.report("invalid-name", path, `Use lower camelCase ${toCamelCase(encoded)} ` +
+                "so the TypeScript and wire names round-trip.");
+        }
+        return encoded;
+    }
+    named(values, path, convert) {
+        const result = Object.create(null);
+        for (const [name, value] of Object.entries(values ?? {})) {
+            const fieldPath = `${path}.${name}`;
+            const wireName = this.name(name, fieldPath);
+            if (Object.hasOwn(result, wireName)) {
+                this.report("duplicate-name", fieldPath, `Names collide on ${wireName} after snake_case conversion.`);
+            }
+            result[wireName] = convert(value, fieldPath);
+        }
+        return result;
+    }
+    property(value, path) {
+        if (!Schema.isSchema(value)) {
+            return value;
+        }
+        const cached = this.properties.get(value);
+        if (cached !== undefined) {
+            return cached;
+        }
+        let normalized = value;
+        const definition = propertyDefinition(value);
+        if (definition?.type === "select") {
+            const options = (definition.options ?? []).map((option) => ({
+                ...option,
+                description: option.description ?? "",
+                value: nameToWire(option.value),
+            }));
+            for (const option of definition.options ?? []) {
+                this.name(option.value, `${path}.options`);
+            }
+            const settings = { ...definition };
+            if (typeof settings.default === "string") {
+                settings.default = nameToWire(settings.default);
+            }
+            normalized = p.select(options, settings);
+        }
+        this.properties.set(value, normalized);
+        return normalized;
+    }
+    target(value) {
+        if (typeof value === "string") {
+            return nameToWire(value);
+        }
+        if (typeof value === "function") {
+            return () => this.entity(value());
+        }
+        return this.entity(value);
+    }
+    relationship(value) {
+        if (!isRelationship(value)) {
+            return value;
+        }
+        const normalized = {
+            ...value,
+            inverse: nameToWire(value.inverse),
+            target: this.target(value.target),
+        };
+        if ("on" in value && value.on !== undefined) {
+            return {
+                ...normalized,
+                on: Object.fromEntries(Object.entries(value.on).map(([property, target]) => [
+                    nameToWire(property),
+                    nameToWire(target),
+                ])),
+            };
+        }
+        return normalized;
+    }
+    definition(entity) {
+        const original = entity.definition;
+        const cached = this.definitions.get(original);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const normalized = {
+            ...original,
+            title: nameToWire(original.title),
+            ...(original.source?.currency === undefined
+                ? {}
+                : { source: { ...original.source, currency: nameToWire(original.source.currency) } }),
+            properties: this.named(original.properties, `${entity.name}.properties`, (value, path) => this.property(value, path)),
+            relationships: this.named(original.relationships ?? {}, `${entity.name}.relationships`, (value) => this.relationship(value)),
+            ...(original.indexes === undefined ? {} : { indexes: original.indexes.map(indexToWire) }),
+            ...(original.measures === undefined
+                ? {}
+                : {
+                    measures: this.named(original.measures, `${entity.name}.measures`, (value) => expressionToWire(value)),
+                }),
+        };
+        this.definitions.set(original, normalized);
+        return normalized;
+    }
+    action(value, path) {
+        if (!isAction(value)) {
+            return value;
+        }
+        let input = value.input;
+        try {
+            if (Schema.isSchema(input)) {
+                input = actionInputToWire(input);
+            }
+        }
+        catch (error) {
+            this.report("invalid-action-input", `${path}.input`, error instanceof Error ? error.message : String(error));
+        }
+        const normalized = {
+            ...value,
+            input,
+            permission: value.permission === undefined ? undefined : permissionToWire(value.permission),
+        };
+        if (typeof value.handler === "function") {
+            normalized.handler = (context) => value.handler({ ...context, principal: principalFromWire(context.principal) });
+        }
+        if (typeof value.prepare === "function") {
+            const prepare = value.prepare;
+            normalized.prepare = (context) => prepare({ ...context, principal: principalFromWire(context.principal) });
+        }
+        return normalized;
+    }
+    entity(value) {
+        if (!isEntity(value)) {
+            return value;
+        }
+        const cached = this.entities.get(value);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Register the handle before resolving relationships, which can point back to it.
+        const normalized = { ...value, name: this.name(value.name, value.name) };
+        this.entities.set(value, normalized);
+        const definition = this.definition(value);
+        Object.assign(normalized, {
+            definition,
+            properties: definition.properties,
+            relationships: definition.relationships,
+        });
+        if (isRecord(value.actions)) {
+            Object.assign(normalized, {
+                actions: this.named(value.actions, `${value.name}.actions`, (action, path) => this.action(action, path)),
+            });
+        }
+        return normalized;
+    }
+    role(value) {
+        if (!isRole(value) || value === member) {
+            return value;
+        }
+        const cached = this.roles.get(value);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const normalized = {
+            ...value,
+            name: this.name(value.name, `roles.${value.name}`),
+            permissions: Array.isArray(value.permissions)
+                ? value.permissions.map(permissionToWire)
+                : value.permissions,
+        };
+        this.roles.set(value, normalized);
+        return normalized;
+    }
+}
+/** Canonical definitions feed REST, storage and future transports; the public config stays camelCase. */
+export function authoringToWire(config, user, report) {
+    const encoder = new AuthoringEncoder(report);
+    const normalized = {
+        ...config,
+        entities: (config.entities ?? []).map((entity) => encoder.entity(entity)),
+        ...(config.roles === undefined
+            ? {}
+            : { roles: config.roles.map((role) => encoder.role(role)) }),
+    };
+    if (isRecord(config.member) && Array.isArray(config.member.permissions)) {
+        normalized.member = {
+            ...config.member,
+            permissions: config.member.permissions.map(permissionToWire),
+        };
+    }
+    return { config: normalized, user: encoder.entity(user) };
+}

package/dist/connection.js

@@ -1,7 +1,7 @@
 import { Context, Effect, Layer, Schema } from "effect";
 export const ConnectionTypeId = Symbol.for("@segmentstream-cloud/ontology/Connection");
 /** A connection key, as `connections/connections.py` declares it. */
-export const CONNECTION_KEY = /^[a-z][a-z0-9_]{0,63}$/;
+export const CONNECTION_KEY = /^(?=.{1,64}$)[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
 export const CONNECTION_METHODS = [
     "GET",
     "POST",

package/dist/entity.d.ts

@@ -3,7 +3,6 @@ import type { Measures } from "./measure.js";
 import type { WarehouseSource } from "./source.js";
 import type { Actions } from "./action.js";
 import type { Conflict, NotFound } from "./errors.js";
-import type { SystemProperty } from "./names.js";
 import { type AnyProperty } from "./property.js";
 import type { AnyRelationship, ManyRelationship, OneRelationship } from "./relationship.js";
 import { OntologyReads, OntologyWrites, type FindOptions, type GetOptions, type UpsertResult } from "./runtime.js";
@@ -88,7 +87,7 @@ export type UpdateValues<P, R> = Simplify<{
     readonly [K in ManyKeys<R>]?: ReadonlyArray<string>;
 }>;
 /** Fields an index may cover: declared properties, system properties and `rel.one` relationships. */
-export type IndexField<P, R> = (keyof P & string) | SystemProperty | OneKeys<R>;
+export type IndexField<P, R> = (keyof P & string) | keyof SystemFields | OneKeys<R>;
 /** An index: the covered fields in order, or the fields with options. */
 export type IndexDefinition<Field extends string = string> = ReadonlyArray<Field> | {
     readonly properties: ReadonlyArray<Field>;

package/dist/entity.js

@@ -1,5 +1,7 @@
 import { Effect } from "effect";
 import { p } from "./property.js";
+import { recordFromWire, valuesToWire, findToWire } from "./authoring-records.js";
+import { toSnakeCase } from "./names.js";
 import { OntologyReads, OntologyWrites, } from "./runtime.js";
 export const EntityTypeId = Symbol.for("@segmentstream-cloud/ontology/Entity");
 function idOf(record) {
@@ -25,17 +27,38 @@ export function entity(name, definition) {
         relationships: definition.relationships ?? {},
         ref: p.ref(name),
         get: (record, options) => withReads((runtime) => runtime.get({
-            entity: name,
+            entity: toSnakeCase(name),
             id: idOf(record),
             ...(options?.forUpdate === true ? { forUpdate: true } : {}),
+        })).pipe(Effect.map((record) => recordFromWire(record, definition))),
+        find: (options) => withReads((runtime) => runtime.find({ entity: toSnakeCase(name), options: findToWire(options ?? {}, definition) })).pipe(Effect.map((records) => records.map((record) => recordFromWire(record, definition)))),
+        create: (values) => withWrites((runtime) => runtime.create({ entity: toSnakeCase(name), values: valuesToWire(values, definition) })).pipe(Effect.map((record) => recordFromWire(record, definition))),
+        update: (record, values) => withWrites((runtime) => runtime.update({
+            entity: toSnakeCase(name),
+            id: idOf(record),
+            values: valuesToWire(values, definition),
+        })).pipe(Effect.map((record) => recordFromWire(record, definition))),
+        upsertBy: (property, values) => withWrites((runtime) => runtime.upsertBy({
+            entity: toSnakeCase(name),
+            property: toSnakeCase(property),
+            values: valuesToWire(values, definition),
+        })).pipe(Effect.map((result) => ({
+            ...result,
+            record: recordFromWire(result.record, definition),
+        }))),
+        delete: (record) => withWrites((runtime) => runtime.delete({ entity: toSnakeCase(name), id: idOf(record) })),
+        link: (relationship, record, target) => withWrites((runtime) => runtime.link({
+            entity: toSnakeCase(name),
+            relationship: toSnakeCase(relationship),
+            id: idOf(record),
+            targetId: idOf(target),
+        })),
+        unlink: (relationship, record, target) => withWrites((runtime) => runtime.unlink({
+            entity: toSnakeCase(name),
+            relationship: toSnakeCase(relationship),
+            id: idOf(record),
+            targetId: idOf(target),
         })),
-        find: (options) => withReads((runtime) => runtime.find({ entity: name, options: options ?? {} })),
-        create: (values) => withWrites((runtime) => runtime.create({ entity: name, values })),
-        update: (record, values) => withWrites((runtime) => runtime.update({ entity: name, id: idOf(record), values })),
-        upsertBy: (property, values) => withWrites((runtime) => runtime.upsertBy({ entity: name, property, values })),
-        delete: (record) => withWrites((runtime) => runtime.delete({ entity: name, id: idOf(record) })),
-        link: (relationship, record, target) => withWrites((runtime) => runtime.link({ entity: name, relationship, id: idOf(record), targetId: idOf(target) })),
-        unlink: (relationship, record, target) => withWrites((runtime) => runtime.unlink({ entity: name, relationship, id: idOf(record), targetId: idOf(target) })),
     };
     // Every form of the entity shares `definition`, which is how defineOntology recognises them.
     const self = { ...handle, actions: {} };

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { entity, isEntity } from "./entity.js";
 export type { ActionsBuilder, AnyEntity, AnyStoredEntity, CreateValues, DraftEntity, Entity, EntityDefinition, EntityRecord, IndexDefinition, IndexField, NoActions, Properties, RecordRef, Relationships, SystemFields, UpdateValues, } from "./entity.js";
 export { ActionRejected, Conflict, NotFound, PermissionDenied } from "./errors.js";
 export type { ActionError } from "./errors.js";
-export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, formatManifest, IndexManifest, MANIFEST_VERSION, manifestHash, OntologyManifest, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
+export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, decodeManifestDocument, encodeManifest, formatManifest, IndexManifest, MANIFEST_VERSION, manifestHash, OntologyManifest, OntologyManifestWire, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
 export { SYSTEM_PROPERTIES } from "./names.js";
 export type { SystemProperty } from "./names.js";
 export { check, defineOntology } from "./ontology.js";

package/dist/index.js

@@ -5,7 +5,7 @@ export { CONNECTION_ERROR_REASONS, CONNECTION_KEY, CONNECTION_METHODS, connectio
 export { Diagnostic, DIAGNOSTIC_CODES, formatDiagnostics, InvalidOntology } from "./diagnostics.js";
 export { entity, isEntity } from "./entity.js";
 export { ActionRejected, Conflict, NotFound, PermissionDenied } from "./errors.js";
-export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, formatManifest, IndexManifest, MANIFEST_VERSION, manifestHash, OntologyManifest, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
+export { ActionManifest, actionConnectionKeys, canonicalJson, ConnectionManifest, EntityManifest, EntityPermissionsManifest, decodeManifestDocument, encodeManifest, formatManifest, IndexManifest, MANIFEST_VERSION, manifestHash, OntologyManifest, OntologyManifestWire, PropertyManifest, RelationshipManifest, RoleManifest, SelectOptionManifest, SignInManifest, signInPolicyOf, } from "./manifest.js";
 export { SYSTEM_PROPERTIES } from "./names.js";
 export { check, defineOntology } from "./ontology.js";
 export { DEFAULT_MEMBER_PERMISSIONS, generatedActionPermissions, grants, isAllowed, parsePermission, permissionsOf, READ_VERB, rolesGranting, WILDCARD, } from "./permissions.js";