@aventara/core 0.1.0-pilot.3 → 1.0.0-rc.0

package/dist/framework/framework.factory.js

@@ -2,9 +2,13 @@ import { compileContracts } from "../compiler/contract.compiler.js";
 import { resolveFrameworkConfig } from "../config/config.resolver.js";
 import { validateFrameworkConfig } from "../config/config.validator.js";
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
+import { copyEnvelopeAtDoor, refuseCallerData, } from "../runtime/caller-data.door.js";
 import { createDiagnosticsReporter, createTransactionDiagnosticsChannel, recordDiagnosticsSink, } from "../runtime/diagnostics-reporter.js";
-import { internalFailure } from "../runtime/operation-response.js";
+import { createMisuseReporter, } from "../runtime/misuse-reporter.js";
+import { internalFailure, operationFailure, } from "../runtime/operation-response.js";
 import { createOperationRuntime } from "../runtime/operation-runtime.js";
+import { recordOwnedExecution } from "../runtime/owned-execution.registry.js";
+import { validateOperationEnvelope, validateTransactionEnvelope, } from "../runtime/request-envelope.validator.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { createTransactionPlanAssembler } from "../transactions/transaction-plan-assembler.js";
 import { createTransactionRuntime } from "../transactions/transaction-runtime.js";
@@ -41,25 +45,26 @@ export async function createFramework(config) {
         contracts: compilation.contracts,
         config: resolvedConfig,
     });
-    const executeOperation = (request) => executeTotally(execute, request, resolvedConfig.diagnostics);
+    const misuse = createMisuseReporter(resolvedConfig.misuse);
+    const executeOperation = (request) => executeTotally(execute, request, resolvedConfig.diagnostics, "caller");
     const protocol = {
         version: AVENTARA_PROTOCOL_VERSION,
         hash: compilation.contracts.client.protocol.hash,
     };
-    const assembler = createTransactionPlanAssembler(compilation.contracts, protocol);
+    const assembler = createTransactionPlanAssembler(compilation.contracts, protocol, misuse);
     const framework = {
         entrypoint: resolvedConfig.entrypoint,
         contracts: compilation.contracts,
         application: createOperationFacade(model, (resource, identity, args, requestId) => ({
             ...identity,
-            scope: "application",
+            origin: "application",
             requestId,
             resource,
             arguments: args,
         }), executeOperation),
         client: createOperationFacade(model, (resource, identity, args, requestId) => ({
             ...identity,
-            scope: "client",
+            origin: "client",
             protocol,
             requestId,
             resource,
@@ -67,28 +72,66 @@ export async function createFramework(config) {
         }), executeOperation),
         appTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("application", resource, identity, args === undefined ? {} : args)),
         clientTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("client", resource, identity, args === undefined ? {} : args)),
-        execute: executeOperation,
-        executeTransaction: (request) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics),
+        execute: (request) => executeRequestTotally(execute, request, resolvedConfig.diagnostics, misuse),
+        executeTransaction: (request) => executeTransactionRequestTotally(executeTransaction, request, resolvedConfig.diagnostics, misuse),
         transaction: ((operations, options) => runTransactionTotally(executeTransaction, assembler, operations, requestIdOf(options), resolvedConfig.diagnostics)),
     };
     recordDiagnosticsSink(framework, resolvedConfig.diagnostics);
+    recordOwnedExecution(framework, {
+        execute: (request) => executeTotally(execute, request, resolvedConfig.diagnostics, "owned"),
+        executeTransaction: (request) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics, undefined, { source: "owned" }),
+    });
     return framework;
 }
-async function executeTotally(execute, request, diagnostics) {
+async function executeTotally(execute, request, diagnostics, source) {
     const report = createDiagnosticsReporter(diagnostics, request);
     try {
-        return await execute(request, report);
+        return await execute(request, report, source);
     }
     catch (error) {
         report(error, "A3000");
         return internalFailure();
     }
 }
-async function executeTransactionTotally(execute, request, diagnostics, origins) {
+function executeRequestTotally(execute, request, diagnostics, misuse) {
+    const envelope = copyEnvelopeAtDoor(request, ["protocol", "transport"]);
+    if (!envelope.ok) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Operation arguments failed framework validation.",
+            issues: [refuseCallerData(envelope.error, [], {}, misuse)],
+        }));
+    }
+    const malformed = validateOperationEnvelope(envelope.value);
+    if (malformed.length > 0) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Operation arguments failed framework validation.",
+            issues: malformed,
+        }));
+    }
+    return executeTotally(execute, envelope.value, diagnostics, "caller");
+}
+function executeTransactionRequestTotally(execute, request, diagnostics, misuse) {
+    const envelope = copyEnvelopeAtDoor(request, ["protocol", "transport"]);
+    if (!envelope.ok) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Transaction plan failed framework validation.",
+            issues: [refuseCallerData(envelope.error, [], {}, misuse)],
+        }));
+    }
+    const malformed = validateTransactionEnvelope(envelope.value);
+    if (malformed.length > 0) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Transaction plan failed framework validation.",
+            issues: malformed,
+        }));
+    }
+    return executeTransactionTotally(execute, envelope.value, diagnostics, undefined, { source: "caller" });
+}
+async function executeTransactionTotally(execute, request, diagnostics, origins, planArguments) {
     const channel = createTransactionDiagnosticsChannel(diagnostics, request);
     const report = channel.transaction();
     try {
-        return await execute(request, channel, origins);
+        return await execute(request, channel, origins, planArguments);
     }
     catch (error) {
         report(error, "A3000");
@@ -102,7 +145,7 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
     }
     catch (error) {
         createTransactionDiagnosticsChannel(diagnostics, {
-            scope: "application",
+            origin: "application",
             requestId,
             plan: operations,
         }).transaction()(error, "A3000");
@@ -111,5 +154,5 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
     if (!assembled.ok) {
         return assembled.response;
     }
-    return executeTransactionTotally(execute, { scope: "application", requestId, plan: assembled.plan }, diagnostics, assembled.origins);
+    return executeTransactionTotally(execute, { origin: "application", requestId, plan: assembled.plan }, diagnostics, assembled.origins, { source: "owned", refused: assembled.refused });
 }

package/dist/framework/operation-facade.d.ts

@@ -9,13 +9,9 @@ import type { FrameworkOperationRequest } from "../runtime/operation-request.js"
 import type { OperationResponse } from "../runtime/operation-response.js";
 import type { ApplicationContractView, ClientContractView } from "./contract-view.js";
 /**
- * A model whose Resource names are not literal — the abstract `AdapterModel`
- * behind the default `Framework` — has no Contract to type a call against, so a
- * surface over it is typed as the opaque object it is, and such a caller uses
- * `execute`. It is also what keeps a typed `Framework<M, Cfg>` assignable to
- * `Framework` cheaply: deriving every argument and result over a `string`-keyed
- * Contract, for all sixteen operations, measured at ≈250,000 instantiations for
- * nothing a caller could use.
+ * A model whose Resource names are not literal — the abstract `AdapterModel` behind
+ * the default `Framework` — has no Contract to type a call against, so a surface over
+ * it is typed as the opaque object it is, and such a caller uses `execute`.
  */
 type OpaqueSurface = {
     readonly [resource: string]: unknown;

package/dist/index.d.ts

@@ -1,83 +1,51 @@
 export type { Adapter } from "./adapters/adapter.interface.js";
 export type { AdapterDiscoveryDiagnostic, AdapterDiscoveryDiagnosticCode, } from "./adapters/adapter-discovery-diagnostic.js";
-export type { AdapterField, AdapterLifecycleTrait, AdapterRelationField, AdapterScalarField, } from "./adapters/adapter-field.js";
-export type { AdapterIdentifier, AdapterScalarFieldKey, } from "./adapters/adapter-identifier.js";
 export type { AdapterModel } from "./adapters/adapter-model.js";
-export type { AdapterOperation } from "./adapters/adapter-operation.js";
-export type { AdapterOperationExecutor } from "./adapters/adapter-operation-executor.interface.js";
-export type { AdapterFieldKey, AdapterFieldMap, AdapterResource, } from "./adapters/adapter-resource.js";
-export type { ContractCompilationResult, FrameworkContracts, } from "./compiler/contract.compiler.js";
-export { compileContracts } from "./compiler/contract.compiler.js";
+export type { FrameworkContracts } from "./compiler/contract.compiler.js";
 export type { ContractCompilerDiagnostic, ContractCompilerDiagnosticCode, } from "./compiler/contract-compiler-diagnostic.js";
-export type { ResolvedFrameworkConfig, ResolvedFrameworkScopeConfig, } from "./config/config.resolver.js";
-export { resolveFrameworkConfig } from "./config/config.resolver.js";
-export { validateFrameworkConfig } from "./config/config.validator.js";
 export type { ConfigDiagnostic, ConfigDiagnosticCode, } from "./config/config-diagnostic.js";
 export type { ConfigLayer, RequestOrigin } from "./config/config-layer.js";
 export type { AddedScalarFieldConfig, FrameworkFieldsShape, KnownScalarFieldConfig, } from "./config/define-fields.js";
 export { defineFields } from "./config/define-fields.js";
-export type { ConfigFieldKey, EffectiveFieldKey, EffectiveFieldKeyAt, } from "./config/effective-fields.js";
+export type { ConfigFieldKey, EffectiveFieldKey, } from "./config/effective-fields.js";
 export type { FrameworkFieldBehaviorConfig, FrameworkReadBehavior, FrameworkResourceBehaviorsConfig, } from "./config/framework-behaviors-config.js";
 export type { AnyFieldsBlock, AnyFrameworkConfig, AnyScopeConfig, FrameworkBehaviorsConfig, FrameworkCapabilitySetRestriction, FrameworkConfig, FrameworkFieldLifecycleTrait, FrameworkFieldRestrictions, FrameworkFieldsConfig, FrameworkLimitsConfig, FrameworkProjectionScopeRestriction, FrameworkRelationCapabilityRestrictions, FrameworkRelationFieldRestrictions, FrameworkRelationMutationRestriction, FrameworkRelationReducerRestriction, FrameworkResourceFieldRestrictions, FrameworkResourceFieldsConfig, FrameworkResourceKey, FrameworkResourceOperationRestrictions, FrameworkResourceRestrictions, FrameworkRestrictionsConfig, FrameworkScalarCapabilityRestrictions, FrameworkScalarFieldConfig, FrameworkScalarFieldRestrictions, FrameworkScalarTypeRef, FrameworkScopeConfig, } from "./config/framework-config.js";
-export type { PipelineConfig, ResolvedPipelineConfig, } from "./config/pipeline-config.js";
+export type { PipelineConfig } from "./config/pipeline-config.js";
 export type { PaginationCapability, ProjectionScope, RelationFilterCapability, RelationMutationDirective, RelationReducer, ScalarFilterOperator, ScalarMutationDirective, WriteScope, } from "./contracts/capability.js";
-export { PROJECTION_SCOPES, WRITE_SCOPES, } from "./contracts/capability.js";
-export type { ClientContractStructureVerdict } from "./contracts/client-contract-structure.validator.js";
-export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
 export type { ApplicationContract, ClientContract, Contract, CoreContract, } from "./contracts/contract.js";
-export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
-export type { ClientContractHashInput } from "./contracts/contract-hash.js";
-export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
 export type { ContractLimits } from "./contracts/contract-limits.js";
-export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export type { ClientContractProtocol, ContractHash, ContractProtocol, } from "./contracts/contract-protocol.js";
-export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export type { EnumDefinition } from "./contracts/enum-definition.js";
 export type { Field, ProjectionScopes, RelationField, RelationFieldCapabilities, RelationMutationCapability, RelationProjectionCapability, RelationReducerCapability, ScalarField, ScalarFieldCapabilities, ScalarFormat, ScopedRelationMutations, ScopedRelationReducers, WriteScopes, } from "./contracts/field.js";
-export { advertisedDirectives, advertisedDirectivesAt, advertisedReducers, advertisedReducersAt, holdsAt, holdsInAnyScope, } from "./contracts/field.js";
 export type { Identifier, ScalarFieldKey } from "./contracts/identifier.js";
 export type { LifecycleTrait } from "./contracts/lifecycle-trait.js";
-export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export type { Resource, ResourceFieldMap } from "./contracts/resource.js";
 export type { OperationAvailability, OperationVariantScopes, ResourceOperations, } from "./contracts/resource-operations.js";
-export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export type { BuiltInScalar, ScalarDefinition, ScalarRegistry, } from "./contracts/scalar.js";
-export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export type { ApplicationScalarForms, ScalarValueType, WireScalarForms, } from "./contracts/scalar-value-type.js";
 export type { TransactionCapability } from "./contracts/transaction-capability.js";
-export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
-export type { ApplicationContractView } from "./framework/contract-view.js";
 export { createFramework } from "./framework/framework.factory.js";
 export type { Framework } from "./framework/framework.js";
 export type { FrameworkConstructionDiagnostic, FrameworkConstructionStage, } from "./framework/framework-construction.error.js";
 export { FrameworkConstructionError } from "./framework/framework-construction.error.js";
-export type { CreateDataInput, CursorInput, FieldKey, IncludeInput, NullsOrder, OperationArgumentMap, OperationArgumentsFor, OrderByEntry, OrderByInput, ProjectionEntry, RelationMutationAction, RelationProjectionInput, ResourceKey, ScalarFilterInput, ScalarMutationAction, ScalarOrderInput, SelectInput, SortDirection, UniqueWhereInput, UpdateDataInput, WhereInput, } from "./operations/operation-arguments.js";
+export type { CreateDataInput, CursorInput, FieldKey, IncludeInput, NullsOrder, OperationArgumentMap, OperationArgumentsFor, OrderByEntry, OrderByInput, ProjectionEntry, RelationProjectionInput, ResourceKey, ScalarOrderInput, SelectInput, SortDirection, UniqueWhereInput, UpdateDataInput, WhereInput, } from "./operations/operation-arguments.js";
 export type { DeferredOperationCall, OperationCall, OperationGrammar, OperationSlot, } from "./operations/operation-call.js";
 export type { OperationFamily, OperationIdentity, OperationVariant, } from "./operations/operation-identity.js";
 export type { OperationResultFor } from "./operations/operation-result.js";
-export type { OperationValidationResult, SemanticOperationArguments, } from "./operations/operation-validator.js";
-export { validateOperationArguments } from "./operations/operation-validator.js";
 export type { ValidationCode, ValidationIssue, } from "./operations/validation-code.js";
-export { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "./operations/validation-code.js";
 export { Decimal } from "./runtime/decimal.js";
 export type { FrameworkDiagnostic, FrameworkDiagnosticsSink, OperationDiagnostic, TransactionDiagnostic, } from "./runtime/diagnostics-reporter.js";
 export type { ExecutionOptions } from "./runtime/execution-options.js";
 export type { ComputedReadBehavior, ComputeOnCreate, ComputeOnRead, ComputeOnUpdate, } from "./runtime/field-behavior.js";
 export { FrameworkError } from "./runtime/framework-error.js";
 export type { JsonValue } from "./runtime/json-value.js";
-export type { ApplicationOperationRequest, ClientOperationRequest, ClientProtocolIdentity, FrameworkOperationRequest, OperationScope, } from "./runtime/operation-request.js";
-export type { Cause, OperationCode, OperationErrorCode, OperationFailureResponse, OperationInternalErrorCode, OperationNoMatchResponse, OperationResponse, OperationSuccessCode, OperationSuccessDataCode, OperationSuccessResponse, } from "./runtime/operation-response.js";
-export { OPERATION_CODES, operationFailure, operationNoMatch, operationSuccess, } from "./runtime/operation-response.js";
+export type { FrameworkMisuseEvent, FrameworkMisuseSink, } from "./runtime/misuse-reporter.js";
+export type { Cause, OperationCode, OperationErrorCode, OperationFailureResponse, OperationNoMatchResponse, OperationResponse, OperationSuccessCode, OperationSuccessDataCode, OperationSuccessResponse, } from "./runtime/operation-response.js";
 export type { AfterHook, BeforeHook, Filter, Guard, Interceptor, Pipe, PipelineContext, PipelineTransportContext, } from "./runtime/pipeline.js";
-export type { BuiltinNonRow, DeferredOperation, Operation, OperationFingerprint, OperationReferenceSurface, ReferenceableField, ReferenceBuilder, SingleRowResult, TransactionPlan, TransactionResults, TransactionRunner, } from "./transactions/deferred-operation.js";
-export type { OperationFingerprintNode } from "./transactions/operation-fingerprint.js";
-export { computeOperationFingerprint, isOperationFingerprint, } from "./transactions/operation-fingerprint.js";
+export type { Operation, OperationReferenceSurface, ReferenceableField, ReferenceBuilder, SingleRowResult, TransactionResults, TransactionRunner, } from "./transactions/deferred-operation.js";
 export type { TransactionIntegrityViolation } from "./transactions/transaction-integrity-error.js";
 export { TransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
-export type { TransactionCreateDataInput, TransactionOperationArgumentsFor, TransactionReference, TransactionReferenceCandidate, TransactionScalarValue, TransactionUpdateDataInput, } from "./transactions/transaction-reference.js";
-export { isTransactionReferenceCandidate, isTransactionReferenceObject, } from "./transactions/transaction-reference.js";
-export type { ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";
+export type { TransactionReference } from "./transactions/transaction-reference.js";
 export type { TransactionCommittedResponse, TransactionResponse, } from "./transactions/transaction-response.js";
-export { transactionCommitted, transactionInfrastructureFailure, transactionOperationFailure, } from "./transactions/transaction-response.js";
 export type { TransactionSlotPathViolation } from "./transactions/transaction-slot-path-error.js";
 export { TransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/index.js

@@ -1,27 +1,7 @@
-export { compileContracts } from "./compiler/contract.compiler.js";
-export { resolveFrameworkConfig } from "./config/config.resolver.js";
-export { validateFrameworkConfig } from "./config/config.validator.js";
 export { defineFields } from "./config/define-fields.js";
-export { PROJECTION_SCOPES, WRITE_SCOPES, } from "./contracts/capability.js";
-export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
-export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
-export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
-export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
-export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
-export { advertisedDirectives, advertisedDirectivesAt, advertisedReducers, advertisedReducersAt, holdsAt, holdsInAnyScope, } from "./contracts/field.js";
-export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
-export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
-export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
-export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
 export { createFramework } from "./framework/framework.factory.js";
 export { FrameworkConstructionError } from "./framework/framework-construction.error.js";
-export { validateOperationArguments } from "./operations/operation-validator.js";
-export { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "./operations/validation-code.js";
 export { Decimal } from "./runtime/decimal.js";
 export { FrameworkError } from "./runtime/framework-error.js";
-export { OPERATION_CODES, operationFailure, operationNoMatch, operationSuccess, } from "./runtime/operation-response.js";
-export { computeOperationFingerprint, isOperationFingerprint, } from "./transactions/operation-fingerprint.js";
 export { TransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
-export { isTransactionReferenceCandidate, isTransactionReferenceObject, } from "./transactions/transaction-reference.js";
-export { transactionCommitted, transactionInfrastructureFailure, transactionOperationFailure, } from "./transactions/transaction-response.js";
 export { TransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/internal.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `@aventara/core/internal` is not public API.
+ *
+ * It holds what Aventara's own packages (the adapters, the client generator,
+ * the testing kit) need from core and an application does not. It carries no
+ * stability promise: any export here may change or disappear in any release,
+ * including a patch release. Applications import from `@aventara/core`.
+ */
+export type { AdapterField, AdapterLifecycleTrait, AdapterRelationField, AdapterScalarField, } from "./adapters/adapter-field.js";
+export type { AdapterIdentifier, AdapterScalarFieldKey, } from "./adapters/adapter-identifier.js";
+export type { AdapterOperation } from "./adapters/adapter-operation.js";
+export type { AdapterOperationExecutor } from "./adapters/adapter-operation-executor.interface.js";
+export type { AdapterFieldKey, AdapterFieldMap, AdapterResource, } from "./adapters/adapter-resource.js";
+export { compileContracts } from "./compiler/contract.compiler.js";
+export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
+export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
+export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
+export type { ClientContractHashInput } from "./contracts/contract-hash.js";
+export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
+export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
+export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
+export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
+export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
+export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
+export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
+export type { ApplicationContractView } from "./framework/contract-view.js";
+export type { SemanticOperationArguments } from "./operations/operation-validator.js";
+export { VALIDATION_CODES } from "./operations/validation-code.js";
+export type { ApplicationOperationRequest, ClientOperationRequest, ClientProtocolIdentity, FrameworkOperationRequest, } from "./runtime/operation-request.js";
+export { OPERATION_CODES } from "./runtime/operation-response.js";
+export type { BuiltinNonRow, OperationFingerprint, } from "./transactions/deferred-operation.js";
+export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";
+export type { ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";

package/dist/internal.js

@@ -0,0 +1,16 @@
+export { compileContracts } from "./compiler/contract.compiler.js";
+export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
+export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
+export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
+export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
+export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
+export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
+export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
+export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
+export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
+export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
+export { VALIDATION_CODES } from "./operations/validation-code.js";
+export { OPERATION_CODES } from "./runtime/operation-response.js";
+export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";

package/dist/json/avz.d.ts

@@ -0,0 +1,96 @@
+import type { JsonSchemaPrimitive, JsonShape, JsonShapeValue } from "../contracts/json-shape.js";
+/** The forms a Json Shape takes. */
+export type AvZKind = "string" | "number" | "int" | "boolean" | "null" | "literal" | "enum" | "object" | "array" | "tuple" | "record" | "union" | "discriminatedUnion" | "optional" | "nullable";
+/**
+ * A Json Shape built with {@link AvZ}: opaque, its `kind` the only member. Its
+ * TypeScript type is `AvZ.infer<typeof shape>`.
+ */
+export interface AvZShape<Value = unknown, Kind extends AvZKind = AvZKind> extends JsonShape<Value> {
+    readonly kind: Kind;
+}
+/** The fields of an object shape, by key. */
+export type AvZFields = {
+    readonly [key: string]: AvZShape;
+};
+declare const avzOptionalKey: unique symbol;
+/** Marks a shape whose object key may be left out. Type-level only. */
+interface AvZOptionalKey {
+    readonly [avzOptionalKey]: true;
+}
+type FieldKeysOptional<Fields extends AvZFields> = {
+    [Key in keyof Fields]: Fields[Key] extends AvZOptionalKey ? Key : never;
+}[keyof Fields];
+type Flatten<T> = {
+    [Key in keyof T]: T[Key];
+} & {};
+/** The value an object shape describes. */
+type AvZObjectValue<Fields extends AvZFields> = ObjectValueOf<Fields, FieldKeysOptional<Fields>>;
+type ObjectValueOf<Fields extends AvZFields, Optional extends keyof Fields> = Flatten<{
+    -readonly [Key in Exclude<keyof Fields, Optional>]: JsonShapeValue<Fields[Key]>;
+} & {
+    -readonly [Key in Optional]?: JsonShapeValue<Fields[Key]>;
+}>;
+/** An object shape: closed, so a key it does not declare is refused. */
+export interface AvZObject<Fields extends AvZFields = AvZFields> extends AvZShape<AvZObjectValue<Fields>, "object"> {
+    readonly fields: Fields;
+}
+/** A shape whose object key may be left out. */
+export interface AvZOptional<Inner extends AvZShape = AvZShape> extends AvZShape<JsonShapeValue<Inner> | undefined, "optional">, AvZOptionalKey {
+}
+/** A shape that also admits `null`. */
+export type AvZNullable<Inner extends AvZShape = AvZShape> = AvZShape<JsonShapeValue<Inner> | null, "nullable"> & (Inner extends AvZOptionalKey ? AvZOptionalKey : unknown);
+/** A value a literal shape may hold. */
+export type AvZLiteralValue = JsonSchemaPrimitive;
+/** What keys a record shape: any string, an enum's values or one literal. */
+type AvZRecordKey = AvZShape<string, "string"> | AvZShape<string, "enum"> | AvZShape<string, "literal">;
+/** An option of a discriminated union: an object whose discriminator is a literal or an enum. */
+type AvZDiscriminable<Discriminator extends string> = AvZObject<{
+    readonly [Key in Discriminator]: AvZShape<AvZLiteralValue, "literal"> | AvZShape<string, "enum">;
+} & AvZFields>;
+type TupleValue<Items extends readonly AvZShape[]> = {
+    -readonly [Index in keyof Items]: JsonShapeValue<Items[Index]>;
+};
+/**
+ * Builds Json Shapes: the type of a Json field, declared in the configuration as
+ * `fields: { Post: { meta: { json: AvZ.object({ … }) } } }`. Types only — no
+ * rules, refinements, transforms or defaults. Objects are closed: a key the shape
+ * does not declare is refused.
+ */
+export declare class AvZ {
+    private constructor();
+    /** Any string. */
+    static readonly string: () => AvZShape<string, "string">;
+    /** Any finite number. */
+    static readonly number: () => AvZShape<number, "number">;
+    /** An integer (a safe one). */
+    static readonly int: () => AvZShape<number, "int">;
+    /** `true` or `false`. */
+    static readonly boolean: () => AvZShape<boolean, "boolean">;
+    /** `null`. */
+    static readonly null: () => AvZShape<null, "null">;
+    /** Exactly `value`: a string, a finite number, a boolean or `null`. */
+    static readonly literal: <const Value extends AvZLiteralValue>(value: Value) => AvZShape<Value, "literal">;
+    /** One of `values`. */
+    static readonly enum: <const Values extends readonly [string, ...string[]]>(values: Values) => AvZShape<Values[number], "enum">;
+    /** An object with exactly these keys; `AvZ.optional` marks one that may be left out. */
+    static readonly object: <const Fields extends AvZFields>(fields: Fields) => AvZObject<Fields>;
+    /** A list of `item`s. */
+    static readonly array: <Item extends AvZShape>(item: Item) => AvZShape<JsonShapeValue<Item>[], "array">;
+    /** A list of exactly these items, in order. */
+    static readonly tuple: <const Items extends readonly [AvZShape, ...AvZShape[]]>(items: Items) => AvZShape<TupleValue<Items>, "tuple">;
+    /** An object of `value`s, keyed by any string, an enum's values or a literal. */
+    static readonly record: <Key extends AvZRecordKey, Value extends AvZShape>(key: Key, value: Value) => AvZShape<Record<JsonShapeValue<Key>, JsonShapeValue<Value>>, "record">;
+    /** Any one of `options`. */
+    static readonly union: <const Options extends readonly [AvZShape, AvZShape, ...AvZShape[]]>(options: Options) => AvZShape<JsonShapeValue<Options[number]>, "union">;
+    /** One of `options`, told apart by the literal or enum at `discriminator`. */
+    static readonly discriminatedUnion: <Discriminator extends string, const Options extends readonly [AvZDiscriminable<Discriminator>, ...AvZDiscriminable<Discriminator>[]]>(discriminator: Discriminator, options: Options) => AvZShape<JsonShapeValue<Options[number]>, "discriminatedUnion">;
+    /** An object key that may be left out. */
+    static readonly optional: <Inner extends AvZShape>(inner: Inner) => AvZOptional<Inner>;
+    /** `inner`, or `null`. */
+    static readonly nullable: <Inner extends AvZShape>(inner: Inner) => AvZNullable<Inner>;
+}
+export declare namespace AvZ {
+    /** The TypeScript type a shape describes. */
+    type infer<Shape extends JsonShape> = JsonShapeValue<Shape>;
+}
+export {};

package/dist/json/avz.js

@@ -0,0 +1,212 @@
+import * as zodMini from "zod/mini";
+import { registerJsonShape } from "./json-shape.registry.js";
+import { translateZodIssues } from "./zod-issue.translator.js";
+const z = zodMini;
+const SHAPE_PROTOTYPE = Object.freeze(Object.create(null));
+const compiled = new WeakMap();
+function compiledOf(builder, value) {
+    const found = typeof value === "object" && value !== null
+        ? compiled.get(value)
+        : undefined;
+    if (found === undefined) {
+        throw new TypeError(`AvZ.${builder}: every part of a shape must be built with AvZ (a Zod schema or any other value is not accepted).`);
+    }
+    return found;
+}
+function requiredPart(builder, value) {
+    const part = compiledOf(builder, value);
+    if (part.optionalKey) {
+        throw new TypeError(`AvZ.${builder}: AvZ.optional marks an object key that may be left out; use it only for a field of AvZ.object.`);
+    }
+    return part;
+}
+function build(node, zod, schema, optionalKey = false) {
+    const shape = Object.freeze(Object.assign(Object.create(SHAPE_PROTOTYPE), { kind: node.kind }));
+    const frozenSchema = deepFreeze(schema);
+    compiled.set(shape, { node, zod, schema: frozenSchema, optionalKey });
+    registerJsonShape(shape, {
+        schema: frozenSchema,
+        validate: (value) => {
+            const result = zod.safeParse(value);
+            return result.success
+                ? []
+                : translateZodIssues(node, value, result.error.issues);
+        },
+    });
+    return shape;
+}
+function deepFreeze(value) {
+    if (typeof value === "object" && value !== null) {
+        for (const child of Object.values(value)) {
+            deepFreeze(child);
+        }
+        Object.freeze(value);
+    }
+    return value;
+}
+function isLiteralValue(value) {
+    return (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value)));
+}
+const string = () => build({ kind: "string" }, z.string(), { type: "string" });
+const number = () => build({ kind: "number" }, z.number(), { type: "number" });
+const int = () => build({ kind: "int" }, z.int(), { type: "integer" });
+const boolean = () => build({ kind: "boolean" }, z.boolean(), { type: "boolean" });
+const nullShape = () => build({ kind: "null" }, z.null(), { type: "null" });
+const literal = (value) => {
+    if (!isLiteralValue(value)) {
+        throw new TypeError("AvZ.literal: the value must be a string, a finite number, a boolean or null.");
+    }
+    return build({ kind: "literal", value }, z.literal(value), { const: value });
+};
+const enumShape = (values) => {
+    if (!Array.isArray(values) ||
+        values.length === 0 ||
+        values.some((value) => typeof value !== "string") ||
+        new Set(values).size !== values.length) {
+        throw new TypeError("AvZ.enum: the values must be a non-empty list of distinct strings.");
+    }
+    const copy = [...values];
+    return build({ kind: "enum", values: copy }, z.enum(copy), {
+        type: "string",
+        enum: copy,
+    });
+};
+const object = (fields) => {
+    if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
+        throw new TypeError("AvZ.object: the fields must be an object of shapes.");
+    }
+    const nodes = {};
+    const zods = {};
+    const properties = {};
+    const required = [];
+    for (const key of Object.keys(fields)) {
+        const part = compiledOf("object", fields[key]);
+        nodes[key] = part.node;
+        zods[key] = part.zod;
+        properties[key] = part.schema;
+        if (!part.optionalKey) {
+            required.push(key);
+        }
+    }
+    return build({ kind: "object", fields: nodes }, z.strictObject(zods), {
+        type: "object",
+        properties,
+        ...(required.length > 0 ? { required } : {}),
+        additionalProperties: false,
+    });
+};
+const array = (item) => {
+    const part = requiredPart("array", item);
+    return build({ kind: "array", item: part.node }, z.array(part.zod), {
+        type: "array",
+        items: part.schema,
+    });
+};
+const tuple = (items) => {
+    if (!Array.isArray(items) || items.length === 0) {
+        throw new TypeError("AvZ.tuple: the items must be a non-empty list of shapes.");
+    }
+    const parts = items.map((item) => requiredPart("tuple", item));
+    return build({ kind: "tuple", items: parts.map((part) => part.node) }, z.tuple(parts.map((part) => part.zod)), {
+        type: "array",
+        prefixItems: parts.map((part) => part.schema),
+        items: false,
+        minItems: parts.length,
+        maxItems: parts.length,
+    });
+};
+const record = (key, value) => {
+    const keyPart = requiredPart("record", key);
+    const valuePart = requiredPart("record", value);
+    const keyNode = keyPart.node;
+    const keys = keyNode.kind === "enum"
+        ? keyNode.values
+        : keyNode.kind === "literal" && typeof keyNode.value === "string"
+            ? [keyNode.value]
+            : keyNode.kind === "string"
+                ? undefined
+                : null;
+    if (keys === null) {
+        throw new TypeError("AvZ.record: the key must be AvZ.string(), AvZ.enum([...]) or a string AvZ.literal(...).");
+    }
+    const schema = keys === undefined
+        ? { type: "object", additionalProperties: valuePart.schema }
+        : {
+            type: "object",
+            properties: Object.fromEntries(keys.map((entry) => [entry, valuePart.schema])),
+            required: [...keys],
+            additionalProperties: false,
+        };
+    return build({ kind: "record", value: valuePart.node }, z.record(keyPart.zod, valuePart.zod), schema);
+};
+const union = (options) => {
+    if (!Array.isArray(options) || options.length < 2) {
+        throw new TypeError("AvZ.union: the options must be a list of at least two shapes.");
+    }
+    const parts = options.map((option) => requiredPart("union", option));
+    return build({ kind: "union", options: parts.map((part) => part.node) }, z.union(parts.map((part) => part.zod)), {
+        anyOf: parts.map((part) => part.schema),
+    });
+};
+const discriminatedUnion = (discriminator, options) => {
+    if (typeof discriminator !== "string" ||
+        !Array.isArray(options) ||
+        options.length === 0) {
+        throw new TypeError("AvZ.discriminatedUnion: give the discriminator key and a non-empty list of object shapes.");
+    }
+    const parts = options.map((option) => requiredPart("discriminatedUnion", option));
+    const tags = new Map();
+    parts.forEach((part, index) => {
+        const tag = part.node.kind === "object" ? part.node.fields[discriminator] : undefined;
+        const values = tag?.kind === "literal"
+            ? [tag.value]
+            : tag?.kind === "enum"
+                ? tag.values
+                : undefined;
+        if (values === undefined) {
+            throw new TypeError(`AvZ.discriminatedUnion: option ${index} must be an AvZ.object whose "${discriminator}" is an AvZ.literal or an AvZ.enum.`);
+        }
+        for (const value of values) {
+            if (tags.has(value)) {
+                throw new TypeError(`AvZ.discriminatedUnion: options ${tags.get(value)} and ${index} both match "${discriminator}" ${JSON.stringify(value)}.`);
+            }
+            tags.set(value, index);
+        }
+    });
+    return build({
+        kind: "discriminatedUnion",
+        discriminator,
+        options: parts.map((part) => part.node),
+    }, z.discriminatedUnion(discriminator, parts.map((part) => part.zod)), {
+        oneOf: parts.map((part) => part.schema),
+    });
+};
+const optional = (inner) => {
+    const part = compiledOf("optional", inner);
+    return build({ kind: "optional", inner: part.node }, z.optional(part.zod), part.schema, true);
+};
+const nullable = (inner) => {
+    const part = compiledOf("nullable", inner);
+    return build({ kind: "nullable", inner: part.node }, z.nullable(part.zod), { anyOf: [part.schema, { type: "null" }] }, part.optionalKey);
+};
+export class AvZ {
+    constructor() { }
+    static string = string;
+    static number = number;
+    static int = int;
+    static boolean = boolean;
+    static null = nullShape;
+    static literal = literal;
+    static enum = enumShape;
+    static object = object;
+    static array = array;
+    static tuple = tuple;
+    static record = record;
+    static union = union;
+    static discriminatedUnion = discriminatedUnion;
+    static optional = optional;
+    static nullable = nullable;
+}