@atolis-hq/wake 0.2.97 → 0.3.1

package/dist/src/kernel/contracts/checkpoint-store.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/contracts/clock.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/contracts/commands.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/contracts/event-journal.js

@@ -0,0 +1,2 @@
+export class WrongExpectedSequenceError extends Error {
+}

package/dist/src/kernel/contracts/event-schema.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { EventActorKind, EventSourceKind } from './events.js';
+import { causationId, correlationId, eventId } from './identifiers.js';
+import { brandedStringSchema, offsetIsoTimestampSchema } from './schema.js';
+const nonEmptyString = z.string().refine((value) => value.trim().length > 0, {
+    message: 'must not be empty',
+});
+export const eventActorSchema = z
+    .object({
+    kind: z.enum([
+        EventActorKind.System,
+        EventActorKind.Operator,
+        EventActorKind.Agent,
+        EventActorKind.Integration,
+    ]),
+    id: nonEmptyString,
+})
+    .strict();
+export const eventSourceSchema = z
+    .object({
+    kind: z.enum([EventSourceKind.Internal, EventSourceKind.Adapter]),
+    id: nonEmptyString,
+})
+    .strict();
+export const entityRefSchema = z
+    .object({
+    kind: nonEmptyString,
+    id: nonEmptyString,
+})
+    .strict();
+export const eventDraftSchema = z
+    .object({
+    eventId: nonEmptyString.pipe(brandedStringSchema(eventId)),
+    eventType: nonEmptyString,
+    schemaVersion: z.literal(1),
+    occurredAt: offsetIsoTimestampSchema,
+    correlationId: nonEmptyString.pipe(brandedStringSchema(correlationId)),
+    causationId: nonEmptyString.pipe(brandedStringSchema(causationId)),
+    actor: eventActorSchema,
+    source: eventSourceSchema,
+    stream: entityRefSchema,
+    payload: z.unknown(),
+})
+    .strict();
+export const eventEnvelopeSchema = eventDraftSchema
+    .extend({
+    recordedAt: offsetIsoTimestampSchema,
+    sequence: z.number().int().positive(),
+    globalPosition: z.number().int().positive(),
+})
+    .strict();
+export function decodeEventEnvelope(input) {
+    return eventEnvelopeSchema.parse(input);
+}

package/dist/src/kernel/contracts/events.js

@@ -0,0 +1,11 @@
+import { defineClosedVocabulary } from './vocabulary.js';
+export const EventActorKind = defineClosedVocabulary({
+    System: 'system',
+    Operator: 'operator',
+    Agent: 'agent',
+    Integration: 'integration',
+});
+export const EventSourceKind = defineClosedVocabulary({
+    Internal: 'internal',
+    Adapter: 'adapter',
+});

package/dist/src/kernel/contracts/id-generator.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/contracts/identifiers.js

@@ -0,0 +1,8 @@
+export const eventId = (value) => nonEmpty(value, 'event id');
+export const correlationId = (value) => nonEmpty(value, 'correlation id');
+export const causationId = (value) => nonEmpty(value, 'causation id');
+function nonEmpty(value, label) {
+    if (value.trim().length === 0)
+        throw new Error(`${label} must not be empty`);
+    return value;
+}

package/dist/src/kernel/contracts/projection-store.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/contracts/relations.js

@@ -0,0 +1 @@
+export {};

package/dist/src/kernel/contracts/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const offsetIsoTimestampSchema = z.iso.datetime({ offset: true });
+export function brandedStringSchema(construct) {
+    return z.string().transform((value, context) => {
+        try {
+            return construct(value);
+        }
+        catch (error) {
+            context.addIssue({
+                code: 'custom',
+                input: value,
+                message: error instanceof Error ? error.message : 'Invalid branded string',
+            });
+            return z.NEVER;
+        }
+    });
+}

package/dist/src/kernel/contracts/vocabulary.js

@@ -0,0 +1,6 @@
+export const defineClosedVocabulary = (catalogue) => catalogue;
+// How a configured list of required values is matched against observed values.
+export const MatchMode = defineClosedVocabulary({
+    Any: 'any',
+    All: 'all',
+});

package/dist/src/kernel/domain/event-envelope.js

@@ -0,0 +1,29 @@
+import { causationId, correlationId, eventId } from '../contracts/identifiers.js';
+import { offsetIsoTimestampSchema } from '../contracts/schema.js';
+export function createEventDraft(input) {
+    if (input.eventType.trim().length === 0)
+        throw new Error('event type must not be empty');
+    const occurredAt = offsetIsoTimestampSchema.safeParse(input.occurredAt);
+    if (!occurredAt.success)
+        throw new Error('occurred at must be a valid offset ISO timestamp', {
+            cause: occurredAt.error,
+        });
+    assertMetadataId(input.actor.id, 'actor');
+    assertMetadataId(input.source.id, 'source');
+    return {
+        eventId: eventId(input.eventId),
+        eventType: input.eventType,
+        schemaVersion: 1,
+        occurredAt: occurredAt.data,
+        correlationId: correlationId(input.correlationId),
+        causationId: causationId(input.causationId),
+        actor: input.actor,
+        source: input.source,
+        stream: input.stream,
+        payload: input.payload,
+    };
+}
+function assertMetadataId(value, label) {
+    if (value.trim().length === 0)
+        throw new Error(`${label} id must not be empty`);
+}

package/dist/src/kernel/domain/match-mode.js

@@ -0,0 +1,11 @@
+import { MatchMode } from '../contracts/vocabulary.js';
+// The mode governs matching within one list; an empty requirement constrains nothing,
+// so callers AND separate lists together to express "this and that".
+export function matchesRequiredValues(mode, required, observed) {
+    if (required.length === 0)
+        return true;
+    const present = new Set(observed);
+    return mode === MatchMode.All
+        ? required.every((value) => present.has(value))
+        : required.some((value) => present.has(value));
+}

package/dist/src/kernel/domain/relation.js

@@ -0,0 +1,10 @@
+export function createRelation(definition, input) {
+    assertKind(definition.name, input.from.kind, definition.fromKind);
+    assertKind(definition.name, input.to.kind, definition.toKind);
+    return { ...input, definition };
+}
+function assertKind(relationName, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Relation ${relationName} requires ${actual} to be ${expected}`);
+    }
+}

package/dist/src/kernel/index.js

@@ -0,0 +1,17 @@
+export * from './contracts/checkpoint-store.js';
+export * from './contracts/clock.js';
+export * from './contracts/commands.js';
+export * from './contracts/event-journal.js';
+export * from './contracts/event-schema.js';
+export * from './contracts/events.js';
+export * from './contracts/id-generator.js';
+export { causationId, correlationId, eventId } from './contracts/identifiers.js';
+export * from './contracts/projection-store.js';
+export * from './contracts/relations.js';
+export * from './contracts/schema.js';
+export * from './contracts/vocabulary.js';
+export * from './domain/event-envelope.js';
+export * from './domain/match-mode.js';
+export * from './domain/relation.js';
+export * from './infrastructure/system-clock.js';
+export * from './infrastructure/ulid-id-generator.js';

package/dist/src/{lib/clock.js → kernel/infrastructure/system-clock.js}

@@ -1,5 +1,5 @@
-export const systemClock = {
+export class SystemClock {
     now() {
         return new Date();
-    },
-};
+    }
+}

package/dist/src/kernel/infrastructure/ulid-id-generator.js

@@ -0,0 +1,9 @@
+import { ulid } from 'ulid';
+const VALID_PREFIX = /^[a-z][a-z0-9-]*$/;
+export class UlidIdGenerator {
+    next(prefix) {
+        if (!VALID_PREFIX.test(prefix))
+            throw new Error(`Invalid ID prefix: ${prefix}`);
+        return `${prefix}-${ulid().toLowerCase()}`;
+    }
+}