@cratis/chronicle 0.1.0 → 0.2.1

package/readModels/IMaterializedReadModels.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Constructor } from '@cratis/fundamentals';
+
+/**
+ * Defines a system for working with materialized read model instances stored in the sink.
+ */
+export interface IMaterializedReadModels {
+    /**
+     * Gets paginated instances of a read model from the sink.
+     * @param readModelType - The read model type to retrieve.
+     * @param skip - Number of instances to skip. Defaults to zero.
+     * @param take - Number of instances to retrieve. Defaults to 50.
+     * @returns Collection of read model instances.
+     */
+    getInstances<TReadModel>(readModelType: Constructor<TReadModel>, skip?: number, take?: number): Promise<TReadModel[]>;
+
+    /**
+     * Observes changes for a paginated window of read model instances from the sink.
+     * @param readModelType - The read model type to observe.
+     * @param skip - Number of instances to skip. Defaults to zero.
+     * @param take - Number of instances to observe. Defaults to 50.
+     * @returns An async iterable of read model instance collections.
+     */
+    observeInstances<TReadModel>(readModelType: Constructor<TReadModel>, skip?: number, take?: number): AsyncIterable<TReadModel[]>;
+}

package/readModels/IReadModels.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Constructor } from '@cratis/fundamentals';
+import type { IMaterializedReadModels } from './IMaterializedReadModels';
+import type { ReadModelChangeset } from './ReadModelChangeset';
+import type { ReadModelSnapshot } from './ReadModelSnapshot';
+
+/**
+ * Defines a system that works with read models in the event store.
+ */
+export interface IReadModels {
+    /**
+     * Gets the {@link IMaterializedReadModels} for working with materialized read model instances from the sink.
+     */
+    readonly materialized: IMaterializedReadModels;
+
+    /**
+     * Registers all discovered read models.
+     * @returns A promise that resolves when registration completes.
+     */
+    register(): Promise<void>;
+
+    /**
+     * Registers a specific read model type.
+     * @param readModelType - The read model type to register.
+     * @returns A promise that resolves when registration completes.
+     */
+    register<TReadModel>(readModelType: Constructor<TReadModel>): Promise<void>;
+
+    /**
+     * Gets a read model instance by key.
+     * @param readModelType - The read model type to retrieve.
+     * @param key - The read model key.
+     * @param sessionId - Optional session identifier.
+     * @returns The read model instance.
+     */
+    getInstanceById<TReadModel>(readModelType: Constructor<TReadModel>, key: string, sessionId?: string): Promise<TReadModel>;
+
+    /**
+     * Gets all instances of a read model.
+     * @param readModelType - The read model type to retrieve.
+     * @param eventCount - Optional maximum number of events to process.
+     * @returns The read model instances.
+     */
+    getInstances<TReadModel>(readModelType: Constructor<TReadModel>, eventCount?: bigint): Promise<TReadModel[]>;
+
+    /**
+     * Gets snapshots for a read model instance by key.
+     * @param readModelType - The read model type to retrieve snapshots for.
+     * @param key - The read model key.
+     * @returns The read model snapshots.
+     */
+    getSnapshotsById<TReadModel>(readModelType: Constructor<TReadModel>, key: string): Promise<ReadModelSnapshot<TReadModel>[]>;
+
+    /**
+     * Watches changes for a specific read model type.
+     * @param readModelType - The read model type to observe.
+     * @returns An async iterable of read model changes.
+     */
+    watch<TReadModel>(readModelType: Constructor<TReadModel>): AsyncIterable<ReadModelChangeset<TReadModel>>;
+
+    /**
+     * Dehydrates a read model session.
+     * @param sessionId - The session identifier to dehydrate.
+     * @param readModelType - The read model type.
+     * @param key - The read model key.
+     * @returns A promise that resolves when dehydration completes.
+     */
+    dehydrateSession<TReadModel>(sessionId: string, readModelType: Constructor<TReadModel>, key: string): Promise<void>;
+
+    /**
+     * Releases (decrypts) PII properties in a read model instance.
+     * @param readModelType - The read model type.
+     * @param instance - The read model instance with encrypted PII.
+     * @returns The read model instance with decrypted PII values.
+     */
+    release<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel): Promise<TReadModel>;
+
+    /**
+     * Releases (decrypts) PII properties in multiple read model instances.
+     * @param readModelType - The read model type.
+     * @param instances - The read model instances with encrypted PII.
+     * @returns The read model instances with decrypted PII values.
+     */
+    releaseMany<TReadModel>(readModelType: Constructor<TReadModel>, instances: TReadModel[]): Promise<TReadModel[]>;
+}

package/readModels/MaterializedReadModels.ts

@@ -0,0 +1,151 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Constructor } from '@cratis/fundamentals';
+import { JsonSerializer } from '@cratis/fundamentals';
+import { ChronicleConnection } from '../connection';
+import { JsonSchemaGenerator } from '../schemas';
+import { getReadModelMetadata } from './readModel';
+import type { IMaterializedReadModels } from './IMaterializedReadModels';
+
+const defaultTake = 50;
+
+/**
+ * Implements {@link IMaterializedReadModels} by working with the Chronicle materialized read model gRPC service.
+ */
+export class MaterializedReadModels implements IMaterializedReadModels {
+    constructor(
+        private readonly _eventStore: string,
+        private readonly _namespace: string,
+        private readonly _connection: ChronicleConnection
+    ) {}
+
+    /** @inheritdoc */
+    async getInstances<TReadModel>(readModelType: Constructor<TReadModel>, skip: number = 0, take: number = defaultTake): Promise<TReadModel[]> {
+        const readModelIdentifier = this.resolveIdentifier(readModelType);
+        const { page, pageSize, skipWithinPage } = this.toPageParams(skip, take);
+
+        const response = await this._connection.materializedReadModels.getInstances({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModel: readModelIdentifier,
+            Page: page,
+            PageSize: pageSize
+        });
+
+        let instances = response.Instances.map(json => this.deserialize(readModelType, json));
+
+        if (skipWithinPage > 0) {
+            instances = instances.slice(skipWithinPage);
+        }
+
+        return this.releaseInstances(readModelType, instances);
+    }
+
+    /** @inheritdoc */
+    async *observeInstances<TReadModel>(readModelType: Constructor<TReadModel>, skip: number = 0, take: number = defaultTake): AsyncIterable<TReadModel[]> {
+        const readModelIdentifier = this.resolveIdentifier(readModelType);
+        const { page, pageSize, skipWithinPage } = this.toPageParams(skip, take);
+
+        for await (const response of this._connection.materializedReadModels.observeInstances({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModel: readModelIdentifier,
+            Page: page,
+            PageSize: pageSize
+        })) {
+            let instances = response.Instances.map(json => this.deserialize(readModelType, json));
+
+            if (skipWithinPage > 0) {
+                instances = instances.slice(skipWithinPage);
+            }
+
+            yield await this.releaseInstances(readModelType, instances);
+        }
+    }
+
+    private resolveIdentifier<TReadModel>(readModelType: Constructor<TReadModel>): string {
+        const metadata = getReadModelMetadata(readModelType);
+        return metadata?.id.value ?? readModelType.name;
+    }
+
+    private toPageParams(skip: number, take: number): { page: number; pageSize: number; skipWithinPage: number } {
+        if (take <= 0) {
+            return { page: 0, pageSize: Number.MAX_SAFE_INTEGER, skipWithinPage: 0 };
+        }
+
+        const page = skip > 0 ? Math.floor(skip / take) : 0;
+        const skipWithinPage = skip % take;
+
+        return { page, pageSize: take, skipWithinPage };
+    }
+
+    private deserialize<TReadModel>(readModelType: Constructor<TReadModel>, json: string): TReadModel {
+        if (!json) {
+            return Object.create(readModelType.prototype) as TReadModel;
+        }
+        return JsonSerializer.deserialize(readModelType as Constructor<object>, json) as TReadModel;
+    }
+
+    private async releaseInstances<TReadModel>(readModelType: Constructor<TReadModel>, instances: TReadModel[]): Promise<TReadModel[]> {
+        const schema = this.getSchema(readModelType);
+        if (!this.schemaHasComplianceMetadata(schema)) {
+            return instances;
+        }
+
+        return Promise.all(instances.map(instance => this.releaseInstance(readModelType, instance, schema)));
+    }
+
+    private async releaseInstance<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel, schema: string): Promise<TReadModel> {
+        const subject = this.extractSubject(instance);
+        if (!subject) {
+            return instance;
+        }
+
+        const payload = JsonSerializer.serialize(instance);
+        const response = await this._connection.compliance.release({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            Subject: subject,
+            Schema: schema,
+            Payload: payload
+        });
+
+        if (response.HasError) {
+            return instance;
+        }
+
+        return this.deserialize(readModelType, response.Payload);
+    }
+
+    private getSchema<TReadModel>(readModelType: Constructor<TReadModel>): string {
+        const metadata = getReadModelMetadata(readModelType);
+        if (metadata) {
+            return JSON.stringify(metadata.schema);
+        }
+        return JSON.stringify(JsonSchemaGenerator.generate(readModelType) ?? JsonSchemaGenerator.createEmptySchema(readModelType.name));
+    }
+
+    private schemaHasComplianceMetadata(schema: string): boolean {
+        try {
+            const parsed = JSON.parse(schema) as Record<string, unknown>;
+            const properties = parsed.properties as Record<string, Record<string, unknown>> | undefined;
+            if (!properties) {
+                return false;
+            }
+            return Object.values(properties).some(
+                property => Array.isArray(property.compliance) && (property.compliance as unknown[]).length > 0
+            );
+        } catch {
+            return false;
+        }
+    }
+
+    private extractSubject<TReadModel>(instance: TReadModel): string | undefined {
+        const anyInstance = instance as Record<string, unknown>;
+        if (anyInstance.id !== undefined && anyInstance.id !== null) {
+            return String(anyInstance.id);
+        }
+        return undefined;
+    }
+}

package/readModels/ReadModelChangeset.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Represents a change observed for a read model.
+ */
+export interface ReadModelChangeset<TReadModel> {
+    /** The namespace the change belongs to. */
+    readonly namespace: string;
+
+    /** The read model key. */
+    readonly key: string;
+
+    /** The current read model state. */
+    readonly readModel: TReadModel;
+
+    /** Whether the read model was removed. */
+    readonly removed: boolean;
+}

package/readModels/ReadModelSnapshot.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { AppendedEvent, Guid as ContractsGuid } from '@cratis/chronicle.contracts';
+
+/**
+ * Represents a read model snapshot together with the events that produced it.
+ */
+export interface ReadModelSnapshot<TReadModel> {
+    /** The read model state at the snapshot. */
+    readonly readModel: TReadModel;
+
+    /** The events that were applied to reach the snapshot. */
+    readonly events: AppendedEvent[];
+
+    /** When the snapshot occurred. */
+    readonly occurred: Date | undefined;
+
+    /** The correlation identifier for the snapshot, when available. */
+    readonly correlationId: ContractsGuid | undefined;
+}

package/readModels/ReadModels.ts

@@ -0,0 +1,333 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type {
+    AppendedEvent,
+    ReadModelObserverType
+} from '@cratis/chronicle.contracts';
+import {
+    ReadModelObserverType as ContractReadModelObserverType
+} from '@cratis/chronicle.contracts';
+import type { Constructor } from '@cratis/fundamentals';
+import { JsonSerializer } from '@cratis/fundamentals';
+import { IClientArtifactsProvider } from '../artifacts';
+import { toContractsGuid } from '../connection/Guid';
+import { ChronicleConnection } from '../connection';
+import { EventSequenceId } from '../eventSequences/EventSequenceId';
+import { getProjectionMetadata } from '../projections/declarative/projection';
+import { hasFromEventMetadata } from '../projections/modelBound/fromEvent';
+import { getReducerMetadata } from '../reducers/reducer';
+import { JsonSchemaGenerator } from '../schemas';
+import { WellKnownSinks } from '../sinks';
+import { getReadModelMetadata } from './readModel';
+import type { IMaterializedReadModels } from './IMaterializedReadModels';
+import { MaterializedReadModels } from './MaterializedReadModels';
+import type { IReadModels } from './IReadModels';
+import type { ReadModelChangeset } from './ReadModelChangeset';
+import type { ReadModelSnapshot } from './ReadModelSnapshot';
+
+const unlimitedEventCount = BigInt('18446744073709551615');
+
+interface ResolvedReadModel {
+    readonly type: Constructor;
+    readonly identifier: string;
+    readonly eventSequenceId: string;
+    readonly observerType: ReadModelObserverType;
+    readonly observerIdentifier: string;
+    readonly schema: string;
+}
+
+/**
+ * Implements {@link IReadModels} by working with the Chronicle read-model gRPC service.
+ */
+export class ReadModels implements IReadModels {
+    readonly materialized: IMaterializedReadModels;
+
+    constructor(
+        private readonly _eventStore: string,
+        private readonly _namespace: string,
+        private readonly _connection: ChronicleConnection,
+        private readonly _clientArtifacts: IClientArtifactsProvider
+    ) {
+        this.materialized = new MaterializedReadModels(_eventStore, _namespace, _connection);
+    }
+
+    /** @inheritdoc */
+    async register<TReadModel>(readModelType?: Constructor<TReadModel>): Promise<void> {
+        const readModels = this.resolveReadModels(readModelType);
+        if (readModels.length === 0) {
+            return;
+        }
+
+        await this._connection.readModels.registerMany({
+            EventStore: this._eventStore,
+            Owner: 1,
+            Source: 1,
+            ReadModels: readModels.map(readModel => this.toDefinition(readModel))
+        });
+    }
+
+    /** @inheritdoc */
+    async getInstanceById<TReadModel>(readModelType: Constructor<TReadModel>, key: string, sessionId?: string): Promise<TReadModel> {
+        const readModel = this.resolveReadModel(readModelType);
+        const response = await this._connection.readModels.getInstanceByKey({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModelIdentifier: readModel.identifier,
+            EventSequenceId: readModel.eventSequenceId,
+            ReadModelKey: key,
+            SessionId: sessionId ?? ''
+        });
+
+        const instance = this.deserializeReadModel(readModelType, response.ReadModel);
+
+        if (readModel.observerType === ContractReadModelObserverType.Reducer && this.schemaHasComplianceMetadata(readModel.schema)) {
+            return this.release(readModelType, instance);
+        }
+
+        return instance;
+    }
+
+    /** @inheritdoc */
+    async getInstances<TReadModel>(readModelType: Constructor<TReadModel>, eventCount: bigint = unlimitedEventCount): Promise<TReadModel[]> {
+        const readModel = this.resolveReadModel(readModelType);
+        const response = await this._connection.readModels.getAllInstances({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModelIdentifier: readModel.identifier,
+            EventSequenceId: readModel.eventSequenceId,
+            EventCount: eventCount
+        });
+
+        const instances = response.Instances.map(instance => this.deserializeReadModel(readModelType, instance));
+
+        if (readModel.observerType === ContractReadModelObserverType.Reducer && this.schemaHasComplianceMetadata(readModel.schema)) {
+            return this.releaseMany(readModelType, instances);
+        }
+
+        return instances;
+    }
+
+    /** @inheritdoc */
+    async getSnapshotsById<TReadModel>(readModelType: Constructor<TReadModel>, key: string): Promise<ReadModelSnapshot<TReadModel>[]> {
+        const readModel = this.resolveReadModel(readModelType);
+        const response = await this._connection.readModels.getSnapshotsByKey({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModelIdentifier: readModel.identifier,
+            EventSequenceId: readModel.eventSequenceId,
+            ReadModelKey: key
+        });
+
+        return response.Snapshots.map(snapshot => ({
+            readModel: this.deserializeReadModel(readModelType, snapshot.ReadModel),
+            events: (snapshot.Events ?? []) as AppendedEvent[],
+            occurred: snapshot.Occurred?.Value ? new Date(snapshot.Occurred.Value) : undefined,
+            correlationId: snapshot.CorrelationId
+        }));
+    }
+
+    /** @inheritdoc */
+    async *watch<TReadModel>(readModelType: Constructor<TReadModel>): AsyncIterable<ReadModelChangeset<TReadModel>> {
+        const readModel = this.resolveReadModel(readModelType);
+
+        for await (const changeset of this._connection.readModels.watch({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModelIdentifier: readModel.identifier,
+            EventSequenceId: readModel.eventSequenceId
+        })) {
+            yield {
+                namespace: changeset.Namespace,
+                key: changeset.ModelKey,
+                readModel: this.deserializeReadModel(readModelType, changeset.ReadModel),
+                removed: changeset.Removed
+            };
+        }
+    }
+
+    /** @inheritdoc */
+    async dehydrateSession<TReadModel>(sessionId: string, readModelType: Constructor<TReadModel>, key: string): Promise<void> {
+        const readModel = this.resolveReadModel(readModelType);
+        await this._connection.readModels.dehydrateSession({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModelIdentifier: readModel.identifier,
+            EventSequenceId: readModel.eventSequenceId,
+            ReadModelKey: key,
+            SessionId: sessionId
+        });
+    }
+
+    /** @inheritdoc */
+    async release<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel): Promise<TReadModel> {
+        const readModel = this.resolveReadModel(readModelType);
+        const schema = this.getReadModelSchema(readModelType, readModel.identifier);
+        const payload = JsonSerializer.serialize(instance);
+        const subject = this.extractSubject(instance);
+
+        const response = await this._connection.compliance.release({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            Subject: subject,
+            Schema: schema,
+            Payload: payload
+        });
+
+        if (response.HasError) {
+            throw new Error(`Failed to release PII: ${response.Error}`);
+        }
+
+        return this.deserializeReadModel(readModelType, response.Payload);
+    }
+
+    /** @inheritdoc */
+    async releaseMany<TReadModel>(readModelType: Constructor<TReadModel>, instances: TReadModel[]): Promise<TReadModel[]> {
+        const releasePromises = instances.map(instance => this.release(readModelType, instance));
+        return Promise.all(releasePromises);
+    }
+
+    private resolveReadModels<TReadModel>(readModelType?: Constructor<TReadModel>): ResolvedReadModel[] {
+        const resolved = new Map<string, ResolvedReadModel>();
+
+        for (const projectionType of this._clientArtifacts.projections) {
+            const metadata = getProjectionMetadata(projectionType);
+            if (!metadata?.readModelType) {
+                continue;
+            }
+
+            if (readModelType && metadata.readModelType !== readModelType) {
+                continue;
+            }
+
+            const readModelMetadata = getReadModelMetadata(metadata.readModelType);
+            const identifier = readModelMetadata?.id.value ?? metadata.readModelType.name;
+            resolved.set(identifier, {
+                type: metadata.readModelType,
+                identifier,
+                eventSequenceId: metadata.eventSequenceId ?? EventSequenceId.eventLog.value,
+                observerType: ContractReadModelObserverType.Projection,
+                observerIdentifier: metadata.id.value,
+                schema: this.getReadModelSchema(metadata.readModelType, identifier)
+            });
+        }
+
+        for (const modelBoundType of this._clientArtifacts.readModels) {
+            if (!hasFromEventMetadata(modelBoundType)) {
+                continue;
+            }
+
+            if (readModelType && modelBoundType !== readModelType) {
+                continue;
+            }
+
+            const metadata = getReadModelMetadata(modelBoundType);
+            if (!metadata) {
+                continue;
+            }
+
+            resolved.set(metadata.id.value, {
+                type: modelBoundType,
+                identifier: metadata.id.value,
+                eventSequenceId: EventSequenceId.eventLog.value,
+                observerType: ContractReadModelObserverType.Projection,
+                observerIdentifier: metadata.id.value,
+                schema: JSON.stringify(metadata.schema)
+            });
+        }
+
+        for (const reducerType of this._clientArtifacts.reducers) {
+            const metadata = getReducerMetadata(reducerType);
+            if (!metadata?.readModel) {
+                continue;
+            }
+
+            if (readModelType && metadata.readModel !== readModelType) {
+                continue;
+            }
+
+            const readModelMetadata = getReadModelMetadata(metadata.readModel);
+            const identifier = readModelMetadata?.id.value ?? metadata.readModel.name;
+            resolved.set(identifier, {
+                type: metadata.readModel,
+                identifier,
+                eventSequenceId: metadata.eventSequenceId ?? EventSequenceId.eventLog.value,
+                observerType: ContractReadModelObserverType.Reducer,
+                observerIdentifier: metadata.id.value,
+                schema: this.getReadModelSchema(metadata.readModel, identifier)
+            });
+        }
+
+        return Array.from(resolved.values());
+    }
+
+    private resolveReadModel<TReadModel>(readModelType: Constructor<TReadModel>): ResolvedReadModel {
+        const [resolved] = this.resolveReadModels(readModelType);
+        if (!resolved) {
+            throw new Error(`Unknown read model '${readModelType.name}'. Make sure it is decorated and discoverable.`);
+        }
+
+        return resolved;
+    }
+
+    private toDefinition(readModel: ResolvedReadModel) {
+        return {
+            Type: {
+                Identifier: readModel.identifier,
+                Generation: 1
+            },
+            ContainerName: readModel.identifier,
+            DisplayName: readModel.identifier,
+            Sink: {
+                ConfigurationId: toContractsGuid(WellKnownSinks.Null),
+                TypeId: toContractsGuid(WellKnownSinks.MongoDB)
+            },
+            Schema: readModel.schema,
+            Indexes: [],
+            ObserverType: readModel.observerType,
+            ObserverIdentifier: readModel.observerIdentifier,
+            Owner: 1,
+            Source: 1
+        };
+    }
+
+    private getReadModelSchema(readModelType: Constructor, identifier: string): string {
+        const metadata = getReadModelMetadata(readModelType);
+        if (metadata) {
+            return JSON.stringify(metadata.schema);
+        }
+
+        return JSON.stringify(JsonSchemaGenerator.generate(readModelType) ?? JsonSchemaGenerator.createEmptySchema(identifier));
+    }
+
+    private deserializeReadModel<TReadModel>(readModelType: Constructor<TReadModel>, json: string): TReadModel {
+        if (!json) {
+            return Object.create(readModelType.prototype) as TReadModel;
+        }
+        return JsonSerializer.deserialize(readModelType as Constructor<object>, json) as TReadModel;
+    }
+
+    private schemaHasComplianceMetadata(schema: string): boolean {
+        try {
+            const parsed = JSON.parse(schema) as Record<string, unknown>;
+            const properties = parsed.properties as Record<string, Record<string, unknown>> | undefined;
+            if (!properties) {
+                return false;
+            }
+            return Object.values(properties).some(
+                property => Array.isArray(property.compliance) && (property.compliance as unknown[]).length > 0
+            );
+        } catch {
+            return false;
+        }
+    }
+
+    private extractSubject<TReadModel>(instance: TReadModel): string {
+        // By convention, use the 'id' property as the subject
+        const anyInstance = instance as any;
+        if (anyInstance.id !== undefined && anyInstance.id !== null) {
+            return String(anyInstance.id);
+        }
+        throw new Error('Read model instance must have an "id" property to serve as the subject for PII release');
+    }
+}

package/readModels/index.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { ReadModelId } from './ReadModelId';
+export type { IReadModels } from './IReadModels';
+export type { IMaterializedReadModels } from './IMaterializedReadModels';
+export { ReadModels } from './ReadModels';
+export { MaterializedReadModels } from './MaterializedReadModels';
+export type { ReadModelChangeset } from './ReadModelChangeset';
+export type { ReadModelSnapshot } from './ReadModelSnapshot';
+export { readModel, getReadModelMetadata, isReadModel } from './readModel';
+export type { ReadModelMetadata } from './readModel';