@cratis/chronicle 6.52.1 → 6.53.1

package/reactors/index.ts

@@ -6,6 +6,7 @@ export { ReactorDelivery } from './ReactorDelivery.js';
 export { reactor, getReactorMetadata, isReactor } from './reactor.js';
 export { handles } from '../events/handles.js';
 export { onceOnly } from './onceOnly.js';
+export { startAtTail } from './startAtTail.js';
 export { replay } from './replay.js';
 export type { ReactorMetadata } from './reactor.js';
 export type { IReactors } from './IReactors.js';

package/reactors/startAtTail.spec.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describe, expect, it } from 'vitest';
+import { isStartAtTail, startAtTail } from './startAtTail.js';
+
+@startAtTail()
+class MarkedReactor {}
+
+class OrdinaryReactor {}
+
+class InheritedReactor extends MarkedReactor {}
+
+describe('the start-at-tail decorator', () => {
+    it('marks the reactor class', () => {
+        expect(isStartAtTail(MarkedReactor)).toBe(true);
+    });
+
+    it('leaves an unmarked class alone', () => {
+        expect(isStartAtTail(OrdinaryReactor)).toBe(false);
+    });
+
+    it('is not inherited by a subclass', () => {
+        expect(isStartAtTail(InheritedReactor)).toBe(false);
+    });
+
+    it('refuses to decorate anything but a class', () => {
+        const decorate = startAtTail() as unknown as (target: object, context: { kind: string }) => void;
+        expect(() => decorate(() => {}, { kind: 'method' })).toThrow(TypeError);
+    });
+});

package/reactors/startAtTail.ts

@@ -0,0 +1,33 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+
+const METADATA_KEY = 'chronicle:reactor:startAtTail';
+
+/**
+ * A new reactor normally catches up from the beginning of the event sequence, so one whose handlers have side
+ * effects acts on every historical event the moment it is deployed. `@onceOnly()` does not prevent that, because it
+ * only excludes replay.
+ *
+ * Marks a reactor class so that the first time Chronicle sees it, it begins at the tail of the event sequence and
+ * observes only what is appended from then on. A reactor that already has a position keeps it, so the marker is safe
+ * to leave in place. Renaming the reactor or moving it changes its default id and makes it a new reactor, which
+ * starts at the tail again, unless an explicit id is given to `@reactor()`. An explicit replay still replays from the
+ * beginning. Both the Chronicle server and the client must support it; a server that predates it ignores the request.
+ * The marker is not inherited by subclasses.
+ * @returns A class decorator for legacy and standard TypeScript decorators.
+ */
+export function startAtTail(): ClassDecorator & ((value: Function, context: ClassDecoratorContext) => void) {
+    return (target: object, context?: ClassDecoratorContext) => {
+        if (typeof context === 'object' && context.kind !== 'class') {
+            throw new TypeError('Start-at-tail can only decorate a reactor class.');
+        }
+        Reflect.defineMetadata(METADATA_KEY, true, target);
+    };
+}
+
+/** Whether this reactor class is marked to start at the tail (without inheriting the marker). */
+export function isStartAtTail(target: Function): boolean {
+    return Reflect.getOwnMetadata(METADATA_KEY, target) === true;
+}

package/webhooks/WebhookDefinitionBuilder.ts

@@ -1,12 +1,13 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import type {
-    BasicAuthorization,
-    BearerTokenAuthorization,
-    OAuthAuthorization,
-    OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization,
-    WebhookDefinition
+import {
+    EventGenerationDelivery,
+    type BasicAuthorization,
+    type BearerTokenAuthorization,
+    type OAuthAuthorization,
+    type OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization,
+    type WebhookDefinition
 } from '@cratis/chronicle.contracts';
 import { Constructor } from '@cratis/fundamentals';
 import { IEventTypes } from '../events/IEventTypes.js';
@@ -140,7 +141,8 @@ export class WebhookDefinitionBuilder implements IWebhookDefinitionBuilder {
             IsReplayable: this._isReplayable,
             IsActive: this._isActive,
             IsNotReplayable: !this._isReplayable,
-            IsInactive: !this._isActive
+            IsInactive: !this._isActive,
+            GenerationDelivery: EventGenerationDelivery.Compatibility
         };
     }
 }

package/webhooks/Webhooks.ts

@@ -104,7 +104,8 @@ export class Webhooks implements IWebhooks {
             IsReplayable: webhook.IsReplayable,
             IsActive: webhook.IsActive,
             IsNotReplayable: !webhook.IsReplayable,
-            IsInactive: !webhook.IsActive
+            IsInactive: !webhook.IsActive,
+            GenerationDelivery: webhook.GenerationDelivery
         }));
     }