@iwentsourcing/core 0.1.0

package/dist/aggregation/aggregate-handle-context.d.ts

@@ -0,0 +1,21 @@
+import { StateDefinitions } from '../storage/state-declaration.js';
+import { EventRandomSeed } from '../event-store/event-random-seed.js';
+import { EventContextSnapshotClient, EventExecuteMetadata } from '../runtime/runtime.js';
+import { TransactionStateClient } from '../storage/transaction-state-client.js';
+import { RuntimeEnv } from '../environment/runtime-env.js';
+export interface AggregateHandleContext<TState extends StateDefinitions> {
+    random: EventRandomSeed;
+    metadata: EventExecuteMetadata;
+    stream: {
+        name: string;
+        pattern: string;
+        version: string;
+        realm: string;
+        tenant: string;
+        run: number;
+        args: Record<string, string>;
+    };
+    env: RuntimeEnv;
+    state<K extends string & keyof TState>(name: K): TransactionStateClient<TState[K]>;
+    snapshot<K extends string & keyof TState>(name: K): EventContextSnapshotClient<TState[K]>;
+}

package/dist/aggregation/aggregate-handle-context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregate-handle-context.js.map

package/dist/aggregation/aggregate-handle-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-handle-context.js","sourceRoot":"","sources":["../../src/aggregation/aggregate-handle-context.ts"],"names":[],"mappings":""}

package/dist/aggregation/aggregate-handle.d.ts

@@ -0,0 +1,4 @@
+import { StateDefinitions } from '../storage/state-declaration.js';
+import { EventDeclaration } from '../event-store/event-declarations.js';
+import { AggregateHandleContext } from './aggregate-handle-context.js';
+export type AggregateHandle<TState extends StateDefinitions, TEvent extends EventDeclaration<any>> = (evt: TEvent['type']['_output'], ctx: AggregateHandleContext<TState>) => Promise<void> | void;

package/dist/aggregation/aggregate-handle.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregate-handle.js.map

package/dist/aggregation/aggregate-handle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-handle.js","sourceRoot":"","sources":["../../src/aggregation/aggregate-handle.ts"],"names":[],"mappings":""}

package/dist/aggregation/aggregate-interface.d.ts

@@ -0,0 +1,9 @@
+import { StateDefinitions } from '../storage/state-declaration.js';
+import { SnapshotClient } from '../storage/snapshot-client.js';
+import { ObservedClient } from '../storage/observer/observed-client.js';
+export interface AggregateInterface<TState extends StateDefinitions> {
+    snapshot<K extends string & keyof TState>(name: K): SnapshotClient<TState[K]>;
+    observe<K extends string & keyof TState>(name: K): ObservedClient<TState[K]>;
+    state: TState;
+    ensure(eventId: string, signal: AbortSignal): Promise<void>;
+}

package/dist/aggregation/aggregate-interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregate-interface.js.map

package/dist/aggregation/aggregate-interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-interface.js","sourceRoot":"","sources":["../../src/aggregation/aggregate-interface.ts"],"names":[],"mappings":""}

package/dist/aggregation/aggregation-declaration.d.ts

@@ -0,0 +1,75 @@
+import { TypeOf } from '../typing/type-of.js';
+export declare const AggregationDeclaration: import("../typing/object-type-description.js").ObjectTypeDescription<{
+    realm: string;
+    auth: {
+        allowAnonymous: boolean;
+    };
+    pattern: string;
+    version: string;
+    events: {
+        [key: string]: {
+            schema: {
+                schemas: {
+                    [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+                };
+                mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+            };
+            output: string;
+            stream: {
+                pattern: string;
+                version: string;
+            };
+        } | {
+            event: string;
+            schema: {
+                schemas: {
+                    [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+                };
+                mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+            };
+            stream: {
+                pattern: string;
+                version: string;
+            };
+        };
+    };
+    stateGrant: {
+        state: string;
+        methods: ("get" | "range" | "observe" | "iterate" | "observeRange")[];
+        filters: {
+            field: string;
+            value: string;
+        }[];
+        access: "read" | "write";
+    }[];
+    eventGrant: {
+        event: string;
+        filters: {
+            field: string;
+            value: string;
+        }[];
+        access: "read" | "write";
+    }[];
+    runtime: {
+        source: string;
+        exportName: string;
+    };
+    states: {
+        [key: string]: {
+            key: string[];
+            schema: {
+                schemas: {
+                    [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+                };
+                mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+            };
+            indices: {
+                [key: string]: {
+                    fields: string[];
+                    unique: boolean;
+                };
+            };
+        };
+    };
+}>;
+export type AggregationDeclaration = TypeOf<typeof AggregationDeclaration>;

package/dist/aggregation/aggregation-declaration.js

@@ -0,0 +1,21 @@
+import { object } from '../typing/object.js';
+import { string } from '../typing/string.js';
+import { record } from '../typing/record.js';
+import { array } from '../typing/array.js';
+import { StreamState } from '../stream/stream-state.js';
+import { AggregationSource } from './event-source.js';
+import { RuntimeDeclaration } from '../runtime/runtime-declaration.js';
+import { StreamAuthDeclaration } from '../stream/stream-auth-declaration.js';
+import { EventGrant, StateGrant } from '../runtime/permission-grant-schema.js';
+export const AggregationDeclaration = object('AggregationDeclaration', {
+    pattern: string(),
+    version: string(),
+    realm: string(),
+    runtime: RuntimeDeclaration,
+    states: record(string(), StreamState),
+    events: record(string(), AggregationSource),
+    auth: StreamAuthDeclaration,
+    stateGrant: array(StateGrant),
+    eventGrant: array(EventGrant),
+});
+//# sourceMappingURL=aggregation-declaration.js.map

package/dist/aggregation/aggregation-declaration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-declaration.js","sourceRoot":"","sources":["../../src/aggregation/aggregation-declaration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AAE/E,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC,wBAAwB,EAAE;IACrE,OAAO,EAAE,MAAM,EAAE;IACjB,OAAO,EAAE,MAAM,EAAE;IACjB,KAAK,EAAE,MAAM,EAAE;IAEf,OAAO,EAAE,kBAAkB;IAE3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,WAAW,CAAC;IACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,iBAAiB,CAAC;IAC3C,IAAI,EAAE,qBAAqB;IAC3B,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC;IAC7B,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC;CAC9B,CAAC,CAAC"}

package/dist/aggregation/aggregation-definition.d.ts

@@ -0,0 +1,19 @@
+import { StateDefinitions } from '../storage/state-declaration.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { VersionBuilder } from '../runtime/version-builder.js';
+import type { StreamEventGrant, StreamStateGrant } from '../stream/stream-options.js';
+import { StreamAuthOptions } from '../stream/stream-options.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AggregationHandleDeclarations } from './aggregation-handle-declarations.js';
+import { AggregationEventDeclaration } from './aggregation-event-declaration.js';
+export interface AggregationDefinition<TState extends StateDefinitions, TEvent extends AggregationEventDeclaration<TRealm>, THandle extends AggregationHandleDeclarations<TState, TEvent, TRealm>, TRealm extends RealmDefinition<AuthProviders>> {
+    readonly realm: TRealm;
+    readonly pattern: string;
+    readonly version: VersionBuilder;
+    readonly state: TState;
+    readonly handle: THandle;
+    readonly events: TEvent;
+    readonly auth: StreamAuthOptions;
+    readonly stateGrant: readonly StreamStateGrant[];
+    readonly eventGrant: readonly StreamEventGrant[];
+}

package/dist/aggregation/aggregation-definition.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregation-definition.js.map

package/dist/aggregation/aggregation-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-definition.js","sourceRoot":"","sources":["../../src/aggregation/aggregation-definition.ts"],"names":[],"mappings":""}

package/dist/aggregation/aggregation-event-declaration.d.ts

@@ -0,0 +1,5 @@
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { InjectedEvent, InjectedOutput } from './injected-event.js';
+import { EventDeclaration } from '../event-store/event-declarations.js';
+export type AggregationEventDeclaration<TRealm extends RealmDefinition<AuthProviders>> = Record<string, InjectedEvent<EventDeclaration<any>, TRealm> | InjectedOutput<EventDeclaration<any>, TRealm>>;

package/dist/aggregation/aggregation-event-declaration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregation-event-declaration.js.map

package/dist/aggregation/aggregation-event-declaration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-event-declaration.js","sourceRoot":"","sources":["../../src/aggregation/aggregation-event-declaration.ts"],"names":[],"mappings":""}

package/dist/aggregation/aggregation-handle-declarations.d.ts

@@ -0,0 +1,8 @@
+import { StateDefinitions } from '../storage/state-declaration.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { AggregateHandle } from './aggregate-handle.js';
+import { AggregationEventDeclaration } from './aggregation-event-declaration.js';
+export type AggregationHandleDeclarations<TState extends StateDefinitions, TEvent extends AggregationEventDeclaration<TRealm>, TRealm extends RealmDefinition<AuthProviders>> = {
+    [Prop in keyof TEvent]: AggregateHandle<TState, TEvent[Prop]['type']>;
+};

package/dist/aggregation/aggregation-handle-declarations.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregation-handle-declarations.js.map

package/dist/aggregation/aggregation-handle-declarations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-handle-declarations.js","sourceRoot":"","sources":["../../src/aggregation/aggregation-handle-declarations.ts"],"names":[],"mappings":""}

package/dist/aggregation/aggregation-options.d.ts

@@ -0,0 +1,16 @@
+import { StateDeclarations } from '../storage/state-declaration.js';
+import { AggregationHandleDeclarations } from './aggregation-handle-declarations.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import type { StreamEventGrant, StreamStateGrant } from '../stream/stream-options.js';
+import { StreamAuthOptions } from '../stream/stream-options.js';
+import { AggregationEventDeclaration } from './aggregation-event-declaration.js';
+export interface AggregationOptions<TState extends StateDeclarations, TEvent extends AggregationEventDeclaration<TRealm>, THandle extends AggregationHandleDeclarations<TState, TEvent, TRealm>, TRealm extends RealmDefinition<AuthProviders>> {
+    pattern: string;
+    state: TState;
+    handle: THandle;
+    events: TEvent;
+    auth: StreamAuthOptions;
+    stateGrant?: readonly StreamStateGrant[];
+    eventGrant?: readonly StreamEventGrant[];
+}

package/dist/aggregation/aggregation-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aggregation-options.js.map

package/dist/aggregation/aggregation-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-options.js","sourceRoot":"","sources":["../../src/aggregation/aggregation-options.ts"],"names":[],"mappings":""}

package/dist/aggregation/define-aggregation.d.ts

@@ -0,0 +1,7 @@
+import { StateDeclarations } from '../storage/state-declaration.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AggregationHandleDeclarations } from './aggregation-handle-declarations.js';
+import { AggregationOptions } from './aggregation-options.js';
+import { AggregationEventDeclaration } from './aggregation-event-declaration.js';
+export declare function defineAggregation<TState extends StateDeclarations, TEvent extends AggregationEventDeclaration<TRealm>, THandle extends AggregationHandleDeclarations<TState, TEvent, TRealm>, TRealm extends RealmDefinition<AuthProviders>>(realm: TRealm, opts: AggregationOptions<TState, TEvent, THandle, TRealm>): import("../runtime/host-runtime.js").AggregateHostRuntime<TState, TRealm>;

package/dist/aggregation/define-aggregation.js

@@ -0,0 +1,25 @@
+import { createAggregateHost } from '../runtime/create-aggregate-host.js';
+import { generateVersion } from '../realm/generate-version.js';
+export function defineAggregation(realm, opts) {
+    const grants = {
+        stateGrant: opts.stateGrant ?? [],
+        eventGrant: opts.eventGrant ?? [],
+    };
+    return createAggregateHost({
+        realm: realm,
+        version: generateVersion(opts.state, 
+        // TODO verify if injection info needs to be in version
+        Object.entries(opts.events).reduce((map, [key, injected]) => {
+            map[key] = injected.type;
+            return map;
+        }, {}), {}, grants),
+        pattern: opts.pattern,
+        state: opts.state,
+        handle: opts.handle,
+        events: opts.events,
+        auth: opts.auth,
+        stateGrant: opts.stateGrant ?? [],
+        eventGrant: opts.eventGrant ?? [],
+    });
+}
+//# sourceMappingURL=define-aggregation.js.map

package/dist/aggregation/define-aggregation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-aggregation.js","sourceRoot":"","sources":["../../src/aggregation/define-aggregation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAO/D,MAAM,UAAU,iBAAiB,CAK/B,KAAa,EAAE,IAAyD;IACxE,MAAM,MAAM,GAAqB;QAC/B,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,EAAE;QACjC,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,EAAE;KAClC,CAAC;IACF,OAAO,mBAAmB,CAEzB;QACC,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,eAAe,CACtB,IAAI,CAAC,KAAK;QACV,uDAAuD;QACvD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAE/B,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,EAAE;YAC1B,GAAG,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC;YACzB,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,EACN,EAAE,EACF,MAAM,CACP;QACD,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,EAAE;QACjC,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,EAAE;KAClC,CAAC,CAAC;AACL,CAAC"}

package/dist/aggregation/event-source.d.ts

@@ -0,0 +1,55 @@
+import { TypeOf } from '../typing/type-of.js';
+export declare const EventSource: import("../typing/object-type-description.js").ObjectTypeDescription<{
+    schema: {
+        schemas: {
+            [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+        };
+        mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+    };
+    event: string;
+    stream: {
+        pattern: string;
+        version: string;
+    };
+}>;
+export type EventSource = TypeOf<typeof EventSource>;
+export declare const OutputSource: import("../typing/object-type-description.js").ObjectTypeDescription<{
+    schema: {
+        schemas: {
+            [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+        };
+        mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+    };
+    stream: {
+        pattern: string;
+        version: string;
+    };
+    output: string;
+}>;
+export type OutputSource = TypeOf<typeof OutputSource>;
+export declare const AggregationSource: import("../typing/union-type-description.js").UnionTypeDescription<{
+    schema: {
+        schemas: {
+            [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+        };
+        mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+    };
+    event: string;
+    stream: {
+        pattern: string;
+        version: string;
+    };
+} | {
+    schema: {
+        schemas: {
+            [key: string]: import("../json-schema/json-schema.js").JsonSchema;
+        };
+        mainSchema: import("../json-schema/json-schema.js").JsonSchema;
+    };
+    stream: {
+        pattern: string;
+        version: string;
+    };
+    output: string;
+}>;
+export type AggregationSource = TypeOf<typeof AggregationSource>;

package/dist/aggregation/event-source.js

@@ -0,0 +1,25 @@
+import { object } from '../typing/object.js';
+import { string } from '../typing/string.js';
+import { JsonSchemaDescription } from '../json-schema/json-schema-description.js';
+import { union } from '../typing/union.js';
+export const EventSource = object('EventSource', {
+    event: string(),
+    schema: JsonSchemaDescription,
+    stream: object('EventSourceStream', {
+        pattern: string(),
+        version: string(),
+    }),
+});
+export const OutputSource = object('OutputSource', {
+    output: string(),
+    schema: JsonSchemaDescription,
+    stream: object('EventSourceStream', {
+        pattern: string(),
+        version: string(),
+    }),
+});
+export const AggregationSource = union('AggregationSource', [
+    OutputSource,
+    EventSource,
+]);
+//# sourceMappingURL=event-source.js.map

package/dist/aggregation/event-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-source.js","sourceRoot":"","sources":["../../src/aggregation/event-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,aAAa,EAAE;IAC/C,KAAK,EAAE,MAAM,EAAE;IACf,MAAM,EAAE,qBAAqB;IAC7B,MAAM,EAAE,MAAM,CAAC,mBAAmB,EAAE;QAClC,OAAO,EAAE,MAAM,EAAE;QACjB,OAAO,EAAE,MAAM,EAAE;KAClB,CAAC;CACH,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,EAAE;IACjD,MAAM,EAAE,MAAM,EAAE;IAChB,MAAM,EAAE,qBAAqB;IAC7B,MAAM,EAAE,MAAM,CAAC,mBAAmB,EAAE;QAClC,OAAO,EAAE,MAAM,EAAE;QACjB,OAAO,EAAE,MAAM,EAAE;KAClB,CAAC;CACH,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,CAAC,mBAAmB,EAAE;IAC1D,YAAY;IACZ,WAAW;CACZ,CAAC,CAAC"}

package/dist/aggregation/inject-event.d.ts

@@ -0,0 +1,7 @@
+import { StreamDefinition } from '../stream/stream-definition.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { InjectedEvent } from './injected-event.js';
+export declare function injectEvent<TStream extends StreamDefinition<any, any, any, any, TRealm>, TRealm extends RealmDefinition<AuthProviders>, TEventKey extends keyof TStream['events'] & string>(stream: {
+    source: TStream;
+}, key: TEventKey): InjectedEvent<TStream['events'][TEventKey], TRealm>;

package/dist/aggregation/inject-event.js

@@ -0,0 +1,9 @@
+export function injectEvent(stream, key) {
+    return {
+        stream: { version: stream.source.version, pattern: stream.source.pattern },
+        type: stream.source.events[key],
+        event: key,
+        realm: stream.source.realm,
+    };
+}
+//# sourceMappingURL=inject-event.js.map

package/dist/aggregation/inject-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-event.js","sourceRoot":"","sources":["../../src/aggregation/inject-event.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,WAAW,CAKzB,MAA2B,EAC3B,GAAc;IAEd,OAAO;QACL,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;QAC1E,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;QAC/B,KAAK,EAAE,GAAG;QACV,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK;KAC3B,CAAC;AACJ,CAAC"}

package/dist/aggregation/inject-output.d.ts

@@ -0,0 +1,9 @@
+import { StreamDefinition } from '../stream/stream-definition.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { InjectedOutput } from './injected-event.js';
+import { EventDeclaration } from '../event-store/event-declarations.js';
+export declare function injectOutput<TStream extends StreamDefinition<any, any, any, any, TRealm>, TRealm extends RealmDefinition<AuthProviders>, TEventKey extends keyof TStream['outputs'] & string>(stream: {
+    source: TStream;
+}, key: TEventKey): InjectedOutput<TStream['outputs'][TEventKey], TRealm>;
+export declare function injectOutputPattern<TOutput extends EventDeclaration<any>, TRealm extends RealmDefinition<AuthProviders>>(realm: TRealm, streamPattern: string, output: TOutput): InjectedOutput<TOutput, TRealm>;

package/dist/aggregation/inject-output.js

@@ -0,0 +1,17 @@
+export function injectOutput(stream, key) {
+    return {
+        stream: { version: stream.source.version, pattern: stream.source.pattern },
+        type: stream.source.outputs[key],
+        output: key,
+        realm: stream.source.realm,
+    };
+}
+export function injectOutputPattern(realm, streamPattern, output) {
+    return {
+        stream: { pattern: streamPattern, version: '*' },
+        type: output,
+        output: output.key,
+        realm: realm,
+    };
+}
+//# sourceMappingURL=inject-output.js.map

package/dist/aggregation/inject-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-output.js","sourceRoot":"","sources":["../../src/aggregation/inject-output.ts"],"names":[],"mappings":"AAMA,MAAM,UAAU,YAAY,CAK1B,MAA2B,EAC3B,GAAc;IAEd,OAAO;QACL,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE;QAC1E,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC;QAChC,MAAM,EAAE,GAAG;QACX,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK;KAC3B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,mBAAmB,CAIjC,KAAa,EACb,aAAqB,EACrB,MAAe;IAEf,OAAO;QACL,MAAM,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,EAAE;QAChD,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,MAAM,CAAC,GAAG;QAClB,KAAK,EAAE,KAAK;KACb,CAAC;AACJ,CAAC"}

package/dist/aggregation/injected-event.d.ts

@@ -0,0 +1,22 @@
+import { EventDeclaration } from '../event-store/event-declarations.js';
+import { RealmDefinition } from '../realm/realm-definition.js';
+import { AuthProviders } from '../authentication/auth-providers.js';
+import { VersionBuilder } from '../runtime/version-builder.js';
+export interface InjectedEvent<TEvent extends EventDeclaration<any>, TRealm extends RealmDefinition<AuthProviders>> {
+    stream: {
+        version: VersionBuilder | string;
+        pattern: string;
+    };
+    event: string;
+    realm: TRealm;
+    type: TEvent;
+}
+export interface InjectedOutput<TOutput extends EventDeclaration<any>, TRealm extends RealmDefinition<AuthProviders>> {
+    stream: {
+        version: VersionBuilder | string;
+        pattern: string;
+    };
+    output: string;
+    realm: TRealm;
+    type: TOutput;
+}

package/dist/aggregation/injected-event.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=injected-event.js.map

package/dist/aggregation/injected-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injected-event.js","sourceRoot":"","sources":["../../src/aggregation/injected-event.ts"],"names":[],"mappings":""}

package/dist/authentication/auth-provider.d.ts

@@ -0,0 +1,100 @@
+import { TypeOf } from '../typing/type-of.js';
+export declare const AuthProvider: import("../typing/union-type-description.js").UnionTypeDescription<{
+    type: "jwt";
+    secret: string | {
+        type: "secret";
+        name: string;
+    };
+    algorithm: "HS256";
+    issuer: string;
+    audience: string;
+    expirationTime: string;
+} | {
+    type: "openid";
+    jwt: {
+        type: "jwt";
+        secret: string | {
+            type: "secret";
+            name: string;
+        };
+        algorithm: "HS256";
+        issuer: string;
+        audience: string;
+        expirationTime: string;
+    };
+    issuer: string | string[];
+    audience: string | string[] | undefined;
+    clientId: string | undefined;
+    clientSecret: string | {
+        type: "secret";
+        name: string;
+    } | undefined;
+    jwks: {
+        url: string;
+        subKey: string;
+    };
+    token: {
+        url: string;
+        formData: {
+            [key: string]: string;
+        };
+        tokenAttributes: string[] | undefined;
+    } | undefined;
+    authorize: {
+        url: string;
+        queryParams: {
+            [key: string]: string;
+        };
+    } | undefined;
+    deviceCode: {
+        clientSecret: boolean;
+        verificationUriName: string;
+        codeUrl: string;
+        grantType: string;
+        scope: string | undefined;
+    } | undefined;
+} | {
+    type: "token";
+    jwt: {
+        type: "jwt";
+        secret: string | {
+            type: "secret";
+            name: string;
+        };
+        algorithm: "HS256";
+        issuer: string;
+        audience: string;
+        expirationTime: string;
+    };
+    issuer: string;
+    clientId: string;
+    clientSecret: string | {
+        type: "secret";
+        name: string;
+    };
+    token: {
+        url: string;
+        formData: {
+            [key: string]: string;
+        };
+        tokenAttributes: string[] | undefined;
+    };
+    authorize: {
+        url: string;
+        queryParams: {
+            [key: string]: string;
+        };
+    };
+    deviceCode: {
+        clientSecret: boolean;
+        verificationUriName: string;
+        codeUrl: string;
+        grantType: string;
+        scope: string | undefined;
+    };
+    user: {
+        url: string;
+        tokenAttributes: string[] | undefined;
+    };
+}>;
+export type AuthProvider = TypeOf<typeof AuthProvider>;

package/dist/authentication/auth-provider.js

@@ -0,0 +1,6 @@
+import { union } from '../typing/union.js';
+import { OpenIDProvider } from './open-id-provider.js';
+import { JwtStore } from './jwt-store.js';
+import { TokenProvider } from './token-provider.js';
+export const AuthProvider = union('AuthProvider', [OpenIDProvider, JwtStore, TokenProvider], 'type');
+//# sourceMappingURL=auth-provider.js.map

package/dist/authentication/auth-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-provider.js","sourceRoot":"","sources":["../../src/authentication/auth-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,CAC/B,cAAc,EACd,CAAC,cAAc,EAAE,QAAQ,EAAE,aAAa,CAAC,EACzC,MAAM,CACP,CAAC"}

package/dist/authentication/auth-providers.d.ts

@@ -0,0 +1,4 @@
+import { AuthProvider } from './auth-provider.js';
+export interface AuthProviders {
+    readonly [key: string]: AuthProvider;
+}

package/dist/authentication/auth-providers.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=auth-providers.js.map

package/dist/authentication/auth-providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-providers.js","sourceRoot":"","sources":["../../src/authentication/auth-providers.ts"],"names":[],"mappings":""}

package/dist/authentication/create-auth-provider.d.ts

@@ -0,0 +1,8 @@
+import { JwtKeyStoreInstance } from './keystore/jwt-key-store-instance.js';
+import { OpenIdKeyStoreInstance } from './keystore/open-id-key-store-instance.js';
+import { OpenIDProvider } from './open-id-provider.js';
+import { JwtStore } from './jwt-store.js';
+import { RuntimeEnv } from '../environment/runtime-env.js';
+import { TokenProvider } from './token-provider.js';
+import { TokenStoreInstance } from './keystore/token-store-instance.js';
+export declare function createAuthProvider(env: RuntimeEnv, name: string, provider: OpenIDProvider | JwtStore | TokenProvider): JwtKeyStoreInstance | OpenIdKeyStoreInstance | TokenStoreInstance;

package/dist/authentication/create-auth-provider.js

@@ -0,0 +1,19 @@
+import { failNever } from '../utils/fail-never.js';
+import { createJwtInstance } from './create-jwt-instance.js';
+import { createTokenInstance } from './create-token-instance.js';
+import { createOpenIdInstance } from './create-open-id-instance.js';
+export function createAuthProvider(env, name, provider) {
+    if (provider.type === 'openid') {
+        return createOpenIdInstance(env, name, provider);
+    }
+    else if (provider.type === 'jwt') {
+        return createJwtInstance(env, name, provider);
+    }
+    else if (provider.type === 'token') {
+        return createTokenInstance(env, name, provider);
+    }
+    else {
+        failNever(provider, 'unknown provider');
+    }
+}
+//# sourceMappingURL=create-auth-provider.js.map

package/dist/authentication/create-auth-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-auth-provider.js","sourceRoot":"","sources":["../../src/authentication/create-auth-provider.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,UAAU,kBAAkB,CAChC,GAAe,EACf,IAAY,EACZ,QAAmD;IAEnD,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,oBAAoB,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IACnD,CAAC;SAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QACnC,OAAO,iBAAiB,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;SAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QACrC,OAAO,mBAAmB,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;SAAM,CAAC;QACN,SAAS,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;IAC1C,CAAC;AACH,CAAC"}

package/dist/authentication/create-jwt-instance.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeEnv } from '../environment/runtime-env.js';
+import { JwtStore } from './jwt-store.js';
+import { JwtKeyStoreInstance } from './keystore/jwt-key-store-instance.js';
+export declare function createJwtInstance(env: RuntimeEnv, name: string, provider: JwtStore): JwtKeyStoreInstance;