@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/generators/ts/Operation.d.ts

@@ -0,0 +1,54 @@
+import type { Maybe } from "purify-ts";
+import type * as ast from "../../ast/index.js";
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { Reusables } from "./Reusables.js";
+import type { Service } from "./Service.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class Operation extends AbstractConstruct {
+    readonly error: Maybe<ObjectType | ObjectDiscriminatedUnionType>;
+    readonly name: string;
+    readonly parameter: Maybe<ObjectType>;
+    readonly result: Maybe<Type>;
+    private readonly service;
+    constructor({ error, name, lazyBindings, parameter, result, service, ...superParameters }: {
+        error: Maybe<ObjectType | ObjectDiscriminatedUnionType>;
+        name: string;
+        lazyBindings: () => readonly Operation.Binding[];
+        parameter: Maybe<ObjectType>;
+        result: Maybe<Type>;
+        service: Pick<Service, "name">;
+    } & ConstructorParameters<typeof AbstractConstruct>[0]);
+    get bindings(): readonly Operation.Binding[];
+    get interfaceSignature(): Code;
+    get loggingMethodDeclaration(): Code;
+    private get parameterDeclaration();
+    private get returnTypeAnnotation();
+    private readonly lazyBindings;
+}
+export declare namespace Operation {
+    class HttpBinding {
+        private readonly errorResponses;
+        private readonly operation;
+        private readonly request;
+        private readonly resultResponse;
+        private readonly reusables;
+        constructor({ errorResponses, operation, request, resultResponse, reusables, }: {
+            errorResponses: readonly ast.Operation.HttpBinding.ErrorResponse[];
+            operation: Operation;
+            request: ast.Operation.HttpBinding.Request;
+            resultResponse: ast.Operation.HttpBinding.ResultResponse;
+            reusables: Reusables;
+        });
+        httpApiRouteRegistration({ variables, }: {
+            variables: {
+                logger: Code;
+                service: Code;
+            };
+        }): Code;
+    }
+    type Binding = HttpBinding;
+}
+//# sourceMappingURL=Operation.d.ts.map

package/dist/generators/ts/Operation.js

@@ -0,0 +1,206 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class Operation extends AbstractConstruct {
+    error;
+    name;
+    parameter;
+    result;
+    service;
+    constructor({ error, name, lazyBindings, parameter, result, service, ...superParameters }) {
+        super(superParameters);
+        this.error = error;
+        this.lazyBindings = lazyBindings;
+        this.name = name;
+        this.parameter = parameter;
+        this.result = result;
+        this.service = service;
+    }
+    get bindings() {
+        return this.lazyBindings();
+    }
+    get interfaceSignature() {
+        return code `${this.name}(${this.parameterDeclaration}): ${this.returnTypeAnnotation}`;
+    }
+    get loggingMethodDeclaration() {
+        const parametersVariableName = this.parameter
+            .map(() => code `parameters`)
+            .orDefault(code ``);
+        return code `\
+async ${this.name}(${this.parameterDeclaration}): ${this.returnTypeAnnotation} {
+  const logContext: Record<string, unknown> = {
+    service: ${literalOf(this.service.name)},
+    operation: ${literalOf(this.name)}${this.parameter
+            .map((parameter) => code `,\n    parameters: { ${joinCode(parameter.properties.flatMap((property) => property
+            .toLoggableInitializer({
+            variables: {
+                object: parametersVariableName,
+            },
+        })
+            .toList()), { on: "," })} }`)
+            .orDefault(code ``)}
+  };
+  this.logger.trace(logContext, "called");
+  return (await this.delegate.${this.name}(${parametersVariableName}))
+    .ifLeft((error) => {
+      this.logger.error({ ...logContext, error }, "error");
+    })
+    .ifRight((${this.result.map(() => code `result`).orDefault(code ``)}) => {
+      this.logger.debug(${this.result.map((result) => code `{ ...logContext, result: ${result.toLoggableExpression({ variables: { value: code `result` } })} }`).orDefault(code `logContext`)}, "success")
+    });
+}`;
+    }
+    get parameterDeclaration() {
+        return this.parameter
+            .map((parameter) => code `parameters: ${parameter.name
+            .map((name) => code `${name}`)
+            .orDefault(code `{ ${joinCode(parameter.properties.flatMap((property) => property.declaration.toList()), { on: "\n\n" })} }`)}`)
+            .orDefault(code ``);
+    }
+    get returnTypeAnnotation() {
+        return code `Promise<${this.reusables.imports.Either}<${this.error.map((error) => error.expression).orDefault(code `Error`)}, ${this.result.map((result) => result.expression).orDefault(code `void`)}>>`;
+    }
+    lazyBindings;
+}
+__decorate([
+    Memoize()
+], Operation.prototype, "bindings", null);
+__decorate([
+    Memoize()
+], Operation.prototype, "interfaceSignature", null);
+__decorate([
+    Memoize()
+], Operation.prototype, "loggingMethodDeclaration", null);
+__decorate([
+    Memoize()
+], Operation.prototype, "parameterDeclaration", null);
+__decorate([
+    Memoize()
+], Operation.prototype, "returnTypeAnnotation", null);
+(function (Operation) {
+    class HttpBinding {
+        errorResponses;
+        operation;
+        request;
+        resultResponse;
+        reusables;
+        constructor({ errorResponses, operation, request, resultResponse, reusables, }) {
+            this.errorResponses = errorResponses;
+            this.operation = operation;
+            this.request = request;
+            this.resultResponse = resultResponse;
+            this.reusables = reusables;
+        }
+        httpApiRouteRegistration({ variables, }) {
+            const errorDiscriminantPropertyName = this.operation.error
+                .chain((error) => error.discriminatedType)
+                .map((discriminatedType) => discriminatedType.discriminantProperty.name)
+                .extract();
+            invariant(this.errorResponses.length === 0 || errorDiscriminantPropertyName);
+            const mapErrorBranches = [];
+            if (this.errorResponses.length > 0) {
+                mapErrorBranches.push(code `\
+if (${literalOf(errorDiscriminantPropertyName)} in error) {
+  switch (error.${errorDiscriminantPropertyName}) {
+${joinCode(this.errorResponses.map((errorResponse) => {
+                    const errorName = errorResponse.error.name.unsafeCoerce();
+                    const errorType = errorResponse.error.shapeIdentifier;
+                    invariant(errorType.termType === "NamedNode");
+                    return code `case ${literalOf(errorName)}: problemDetailsJson = { status: ${literalOf(errorResponse.statusCode)}, title: ${literalOf(errorName)}, type: ${literalOf(errorType.value)} }; break;`;
+                }), { on: "\n" })}
+  }
+}`);
+            }
+            mapErrorBranches.push(code `problemDetailsJson = ${this.reusables.snippets.errorToProblemDetailsJson}(error);`);
+            const httpApiRouteRegistrationParameters = [];
+            httpApiRouteRegistrationParameters.push(code `${literalOf(this.request.uriTemplate.parts
+                .map((part) => {
+                if (part.type === "literal") {
+                    return part.value;
+                }
+                const { operator, variables } = part;
+                let convertedVariables = variables
+                    .map((variable) => {
+                    let convertedVariable = `:${variable.name}`;
+                    if (variable.modifier?.type === "explode" ||
+                        operator === "+") {
+                        convertedVariable = `${convertedVariable}*`;
+                    }
+                    return convertedVariable;
+                })
+                    .join("/");
+                if (operator === "/") {
+                    convertedVariables = `/${convertedVariables}`;
+                }
+                return convertedVariables;
+            })
+                .join(""))}`);
+            const parameterProperties = new Map();
+            this.operation.parameter.ifJust((parameter) => {
+                for (const property of parameter.properties) {
+                    if (property.kind === "Shacl") {
+                        parameterProperties.set(property.name, property);
+                    }
+                }
+            });
+            const targetSchemas = new Map();
+            for (const [parameterName, parameterSource,] of this.request.parameterSources.entries()) {
+                let targetSchemas_ = targetSchemas.get(parameterSource);
+                if (!targetSchemas_) {
+                    targetSchemas_ = [];
+                    targetSchemas.set(parameterSource, targetSchemas_);
+                }
+                const parameterProperty = parameterProperties.get(parameterName);
+                invariant(parameterProperty);
+                const parameterJsonSchema = parameterProperty.type.jsonValueType.schema;
+                targetSchemas_.push(code `${parameterProperty.name}: ${parameterJsonSchema}`);
+            }
+            for (const [target, properties] of targetSchemas.entries()) {
+                httpApiRouteRegistrationParameters.push(code `${this.reusables.snippets.zValidator}(${literalOf(target === "path" ? "param" : target)}, ${this.reusables.imports.z}.object({ ${joinCode(properties, { on: ", " })} }))`);
+            }
+            httpApiRouteRegistrationParameters.push(code `\
+async (c) =>
+  (await ${variables.service}.${this.operation.name}(${this.request.parameterSources.size > 0
+                ? code `${this.reusables.snippets.sequenceRecord}(${[
+                    ...this.request.parameterSources.entries(),
+                ].reduce((acc, [parameterName, parameterSource]) => {
+                    const parameterProperty = parameterProperties.get(parameterName);
+                    acc[parameterName] =
+                        code `${parameterProperty.type.fromJsonValueFunction.unannotatedUsage}(c.req.valid("${parameterSource === "path" ? "param" : parameterSource}").${parameterName})`;
+                    return acc;
+                }, {})}).unsafeCoerce()`
+                : ""}))
+  .mapLeft(error => {
+    ${mapErrorBranches.length > 1 ? code `let problemDetailsJson: ${this.reusables.snippets.ProblemDetailsJson};` : code `const `}${joinCode(mapErrorBranches, { on: " else " })}
+
+    ${variables.logger}.error({ status: problemDetailsJson.status, type: problemDetailsJson.type }, problemDetailsJson.detail ?? "(no message)");
+
+    return c.json(problemDetailsJson, problemDetailsJson.status ?? 500, { "Content-Type": "application/problem+json" });
+  })
+  .map((${this.operation.result.map(() => "result").orDefault("")}) => ${this.resultResponse.contentType
+                .map((contentType) => {
+                const result = this.operation.result.unsafeCoerce();
+                switch (contentType) {
+                    case "application/json":
+                        return code `c.json(${result.toJsonValueFunction.unannotatedUsage}(result))`;
+                    default:
+                        // contentType satisfies never;
+                        throw new RangeError(contentType);
+                }
+            })
+                .orDefault(code `c.body(null`)}, ${this.resultResponse.statusCode}))
+  .extract()
+`);
+            return code `${this.request.method.toLowerCase()}(${joinCode(httpApiRouteRegistrationParameters, { on: ", " })})`;
+        }
+    }
+    Operation.HttpBinding = HttpBinding;
+})(Operation || (Operation = {}));
+//# sourceMappingURL=Operation.js.map

package/dist/generators/ts/OptionType.d.ts

@@ -1,34 +1,36 @@
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import type { Callable } from "./Callable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
-    readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     readonly jsTypes: readonly [{
         readonly instanceof: "Maybe";
         readonly typeof: "object";
     }];
     readonly kind = "Option";
+    get jsonValueType(): AbstractContainerType<ItemTypeT>["jsonValueType"];
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
+    get equalsFunction(): Callable;
+    get jsonObjectType(): AbstractContainerType<ItemTypeT>["jsonObjectType"];
+    get filterFunction(): Callable;
     get filterType(): Code;
-    get fromRdfResourceValuesFunction(): Code;
+    get fromJsonValueFunction(): AbstractContainerType<ItemTypeT>["fromJsonValueFunction"];
+    get fromJsonObjectFunction(): AbstractContainerType<ItemTypeT>["fromJsonObjectFunction"];
+    get fromRdfResourceValuesFunction(): Callable;
     get graphqlType(): AbstractContainerType.GraphqlType;
-    get hashFunction(): Code;
+    get hashFunction(): Callable;
     get mutable(): boolean;
     get schemaType(): Code;
+    get toJsonValueFunction(): AbstractContainerType<ItemTypeT>["toJsonValueFunction"];
+    get toJsonObjectFunction(): AbstractContainerType<ItemTypeT>["toJsonObjectFunction"];
     get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
-    get validationFunction(): Maybe<Code>;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
+    get validationFunction(): Maybe<Callable>;
+    get valueSparqlConstructTriplesFunction(): Callable;
+    get valueSparqlWherePatternsFunction(): Callable;
     protected get inlineExpression(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
-    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }

package/dist/generators/ts/OptionType.js

@@ -9,14 +9,18 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
-    discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     jsTypes = [
         { instanceof: "Maybe", typeof: "object" },
     ];
     kind = "Option";
+    get jsonValueType() {
+        return this.itemType.jsonValueType;
+    }
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
@@ -31,16 +35,25 @@ export class OptionType extends AbstractContainerType {
         });
     }
     get equalsFunction() {
-        return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
+        return new InlineCallable(code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction.annotatedUsage}))`);
+    }
+    get jsonObjectType() {
+        return this.itemType.jsonObjectType;
     }
     get filterFunction() {
-        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.filterMaybe}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction.unannotatedUsage})`);
     }
     get filterType() {
         return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.maybeFromJsonValue}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+    }
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.maybeFromJsonObject}(${this.itemType.fromJsonObjectFunction.annotatedUsage})`);
+    }
     get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
     }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
@@ -49,7 +62,7 @@ export class OptionType extends AbstractContainerType {
         });
     }
     get hashFunction() {
-        return code `${this.reusables.snippets.hashMaybe}(${this.itemType.hashFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.hashMaybe}(${this.itemType.hashFunction.annotatedUsage})`);
     }
     get mutable() {
         return this.itemType.mutable;
@@ -57,46 +70,34 @@ export class OptionType extends AbstractContainerType {
     get schemaType() {
         return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
+    get toJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.maybeToJsonValue}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
+    }
+    get toJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.maybeToJsonObject}(${this.itemType.toJsonObjectFunction.annotatedUsage})`);
+    }
     get toRdfResourceValueTypes() {
         return this.itemType.toRdfResourceValueTypes;
     }
     get validationFunction() {
-        return Maybe.of(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
+        return Maybe.of(new InlineCallable(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction
+            .map((_) => _.annotatedUsage)
+            .orDefault(this.itemValidationFunctionDefault.annotatedUsage)})`));
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     }
     get inlineExpression() {
         return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
     }
-    fromJsonExpression({ variables, }) {
-        const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
-        const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: code `item` },
-        });
-        return code `${expression}.map(item => (${itemFromJsonExpression}).map(${this.reusables.imports.Maybe}.of)).orDefault(${this.reusables.imports.Either}.of(${this.reusables.imports.Maybe}.empty()))`;
-    }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
     }
-    jsonSchema(parameters) {
-        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
-    }
-    jsonType(parameters) {
-        const itemTypeJsonType = this.itemType.jsonType(parameters);
-        invariant(!itemTypeJsonType.optional);
-        return new AbstractContainerType.JsonType(itemTypeJsonType.expression, {
-            optional: true,
-        });
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
+    toLoggableExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toLoggableExpression({ variables: { value: code `item` } })})).extract()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const itemTypeToRdfExpression = this.itemType.toRdfResourceValuesExpression({
@@ -124,6 +125,12 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "fromJsonValueFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "fromRdfResourceValuesFunction", null);
@@ -136,6 +143,12 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "toJsonValueFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "toJsonObjectFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "validationFunction", null);
@@ -148,9 +161,6 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "inlineExpression", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "jsonType", null);
 (function (OptionType) {
     OptionType.isItemType = AbstractContainerType.isItemType;
 })(OptionType || (OptionType = {}));

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -4,6 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
@@ -46,10 +47,7 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   ${joinCode([
-            ...[
-                ...this.namedObjectTypes,
-                ...this.namedObjectDiscriminatedUnionTypes,
-            ].flatMap((namedObjectType) => {
+            ...this.namedObjectTypes.flatMap((namedObjectType) => {
                 const methodSignatures = this.methodSignatures(namedObjectType);
                 const delegatingMethods = [
                     // object
@@ -90,7 +88,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                     // objectsSync has per-object type logic, not just forwarding
                 ];
                 const runtimeObjectType = (filterFunction, namedObjectType) => {
-                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
+                    return code `{ filter: ${filterFunction.annotatedUsage}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
                 };
                 switch (namedObjectType.kind) {
                     case "Object": {
@@ -105,13 +103,22 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   return this.#objectDiscriminatedUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
+}`);
+                    case "ObjectIntersection":
+                        return delegatingMethods.concat(code `\
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, {
+                            expression: namedObjectType.expression,
+                            fromRdfTypeVariable: Maybe.empty(),
+                        })}, query);
 }`);
                     default:
                         namedObjectType;
                         return [];
                 }
             }),
-            ...(this.namedObjectTypes.length > 0
+            ...(this.namedObjectTypes.some((namedObjectType) => namedObjectType.kind === "Object" ||
+                namedObjectType.kind === "ObjectIntersection")
                 ? [
                     code `\
 #objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
@@ -203,7 +210,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   }`,
                 ]
                 : []),
-            ...(this.namedObjectDiscriminatedUnionTypes.length > 0
+            ...(this.namedObjectTypes.some((namedObjectType) => namedObjectType.kind === "ObjectDiscriminatedUnion")
                 ? [
                     code `\
 #objectDiscriminatedUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {

package/dist/generators/ts/ReferenceCallable.d.ts

@@ -0,0 +1,14 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that's a reference to a snippet, an import, or a global function.
+ *
+ * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
+ */
+export declare class ReferenceCallable extends AbstractCallable {
+    readonly annotatedUsage: Code;
+    readonly unannotatedUsage: Code;
+    constructor(reference: Code | Snippet);
+}
+//# sourceMappingURL=ReferenceCallable.d.ts.map

package/dist/generators/ts/ReferenceCallable.js

@@ -0,0 +1,16 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that's a reference to a snippet, an import, or a global function.
+ *
+ * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
+ */
+export class ReferenceCallable extends AbstractCallable {
+    annotatedUsage;
+    unannotatedUsage;
+    constructor(reference) {
+        super();
+        this.annotatedUsage = this.unannotatedUsage = code `${reference}`;
+    }
+}
+//# sourceMappingURL=ReferenceCallable.js.map

package/dist/generators/ts/Service.d.ts

@@ -0,0 +1,15 @@
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import type { Operation } from "./Operation.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class Service extends AbstractConstruct {
+    readonly name: string;
+    readonly operations: readonly Operation[];
+    constructor({ name, operations, ...superParameters }: {
+        name: string;
+        operations: readonly Operation[];
+    } & ConstructorParameters<typeof AbstractConstruct>[0]);
+    get httpApiFactoryFunction(): Code;
+    get interfaceDeclaration(): Code;
+    get loggingClassDeclaration(): Code;
+}
+//# sourceMappingURL=Service.d.ts.map

package/dist/generators/ts/Service.js

@@ -0,0 +1,53 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class Service extends AbstractConstruct {
+    name;
+    operations;
+    constructor({ name, operations, ...superParameters }) {
+        super(superParameters);
+        this.name = name;
+        this.operations = operations;
+    }
+    get httpApiFactoryFunction() {
+        const variables = { logger: code `logger`, service: code `service` };
+        return code `\
+export function create${this.name}HttpApi<EnvT extends ${this.reusables.imports.HonoEnv}>(service: ${this.name}, options?: { logger?: ${this.reusables.imports.Logger} }) {
+  const logger: ${this.reusables.imports.Logger} = options?.logger ?? ${this.reusables.imports.nopLogger};
+  return new ${this.reusables.imports.Hono}<EnvT>()${joinCode(this.operations.flatMap((operation) => operation.bindings.map((binding) => code `.${binding.httpApiRouteRegistration({ variables })}`)))};
+}`;
+    }
+    get interfaceDeclaration() {
+        return code `export interface ${this.name} { ${joinCode(this.operations.map((operation) => operation.interfaceSignature))} }`;
+    }
+    get loggingClassDeclaration() {
+        return code `\
+export class Logging${this.name} implements ${this.name} {
+  private readonly delegate: ${this.name};
+  private readonly logger: ${this.reusables.imports.Logger};
+
+  constructor({ delegate, logger }: { delegate: ${this.name}, logger: ${this.reusables.imports.Logger} }) {
+    this.delegate = delegate;
+    this.logger = logger;
+  }
+
+  ${joinCode(this.operations.map((operation) => operation.loggingMethodDeclaration))}  
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], Service.prototype, "httpApiFactoryFunction", null);
+__decorate([
+    Memoize()
+], Service.prototype, "interfaceDeclaration", null);
+__decorate([
+    Memoize()
+], Service.prototype, "loggingClassDeclaration", null);
+//# sourceMappingURL=Service.js.map