@tstdl/base 0.93.123 → 0.93.126

package/injector/type-info.d.ts

@@ -1,12 +1,8 @@
-import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
 import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
+import type { ArgumentProvider, Mapper } from './types.js';
 export type InjectMetadata = {
     /** Token overwrite by inject decorator */
     injectToken?: InjectionToken;
-    /** If defined, resolve the token or ForwardRefToken using ForwardRef strategy instead of resolving the token directly */
-    forwardRef?: boolean | ForwardRefInjectionToken;
-    forwardRefTypeHint?: ForwardRefTypeHint;
     /** Whether injection is optional if token is not registered. Set by optional decorator */
     optional?: boolean;
     /** Whether injection should resolve all providers */

package/injector/types.d.ts

@@ -1,9 +1,7 @@
 import type { CancellationSignal } from '../cancellation/index.js';
 import type { Record } from '../types/index.js';
-import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
 import type { DisposeHandler, Injector, ProvidersItem } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
-import type { InjectionToken } from './token.js';
 /**
  * Transient: new resolution for every resolve
  * resolution: one resolution per resolve tree
@@ -11,26 +9,22 @@ import type { InjectionToken } from './token.js';
  * singleton: one resolution at injector where token is registered
  */
 export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
-export type ResolveContext<D extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
+export type ResolveContext<D extends Record = Record<PropertyKey, unknown>> = Pick<Injector, 'resolve' | 'resolveAll'> & {
     readonly data: ResolveContextData<D>;
     readonly cancellationSignal: CancellationSignal;
     addDisposeHandler(handler: DisposeHandler): void;
 };
-export type AfterResolveContext<D extends Record> = {
+export type AfterResolveContext<D extends Record = Record<PropertyKey, unknown>> = {
     readonly data: ResolveContextData<D>;
     readonly cancellationSignal: CancellationSignal;
     addDisposeHandler(handler: DisposeHandler): void;
 };
 export type Mapper<T = any, U = unknown> = (value: T) => U;
-export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
-export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
-export type ResolveOptions<T, A> = {
+export type ArgumentProvider<T = unknown, D extends Record = Record<PropertyKey, unknown>> = (context: ResolveContext<D>) => T;
+export type ResolveOptions = {
     optional?: boolean;
     skipSelf?: boolean | number;
     onlySelf?: boolean;
-    /** If defined, resolve the token using ForwardRef strategy instead of resolving the token directly can be used to circumvent circular dependency problems */
-    forwardRef?: boolean | ForwardRefInjectionToken<T, A>;
-    forwardRefTypeHint?: ForwardRefTypeHint;
 };
 /**
  * Data to store between different stages like resolve and afterResolve

package/logger/tests/pretty-print.test.d.ts

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

package/logger/{formatters → tests}/pretty-print.test.js

@@ -5,7 +5,7 @@ vi.mock('#/supports.js', () => ({
     supportsColoredStderr: true,
 }));
 import { LogLevel } from '../level.js';
-import { PrettyPrintLogFormatter } from './pretty-print.js';
+import { PrettyPrintLogFormatter } from '../formatters/pretty-print.js';
 describe('PrettyPrintLogFormatter', () => {
     const formatter = new PrettyPrintLogFormatter();
     it('should format a log entry with an error and no context', () => {

package/logger/transports/console.d.ts

@@ -1,14 +1,15 @@
 import { type InjectionToken, type Resolvable, type resolveArgumentType } from '../../injector/index.js';
 import type { ProvidersItem } from '../../injector/injector.js';
+import type { TypedOmit } from '../../types/index.js';
 import { LogFormatter, type LogPayload } from '../formatter.js';
-import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions } from '../transport.js';
 export declare class ConsoleLogTransportOptions extends LogTransportOptions {
     formatter: InjectionToken<LogFormatter>;
+    stderrOnly?: boolean;
 }
 export declare class ConsoleLogTransport extends LogTransport implements Resolvable<ConsoleLogTransportOptions> {
     #private;
     readonly [resolveArgumentType]: ConsoleLogTransportOptions;
     log(payload: LogPayload): void;
 }
-export declare function provideConsoleLogTransport(formatter: InjectionToken<LogFormatter>, level?: LogLevel): ProvidersItem;
+export declare function provideConsoleLogTransport(formatter: InjectionToken<LogFormatter>, options?: TypedOmit<ConsoleLogTransportOptions, 'formatter'>): ProvidersItem;

package/logger/transports/console.js

@@ -12,6 +12,7 @@ import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions, provideLogTransport } from '../transport.js';
 export class ConsoleLogTransportOptions extends LogTransportOptions {
     formatter;
+    stderrOnly;
 }
 const consoleLevelFuncMap = {
     [LogLevel.Error]: 'error',
@@ -26,7 +27,7 @@ let ConsoleLogTransport = class ConsoleLogTransport extends LogTransport {
     #formatter = isDefined(this.#argument?.formatter) ? inject(this.#argument.formatter) : inject(LogFormatter);
     log(payload) {
         const message = this.#formatter.format(payload);
-        const consoleFunc = consoleLevelFuncMap[payload.level];
+        const consoleFunc = (this.#argument?.stderrOnly == true) ? 'error' : consoleLevelFuncMap[payload.level];
         console[consoleFunc](message);
     }
 };
@@ -34,6 +35,6 @@ ConsoleLogTransport = __decorate([
     Singleton()
 ], ConsoleLogTransport);
 export { ConsoleLogTransport };
-export function provideConsoleLogTransport(formatter, level) {
-    return provideLogTransport({ useToken: ConsoleLogTransport, defaultArgument: { formatter, level } });
+export function provideConsoleLogTransport(formatter, options) {
+    return provideLogTransport({ useToken: ConsoleLogTransport, defaultArgument: { ...options, formatter } });
 }

package/notification/api/notification.api.d.ts

@@ -14,7 +14,7 @@ export declare const notificationApiDefinition: {
             };
             credentials: true;
             dataStream: {
-                idProvider: (item: NotificationStreamItem) => import("../../types/tagged.js").Tagged<string, "column", import("drizzle-orm").IsPrimaryKey<import("drizzle-orm").HasDefault<import("drizzle-orm/pg-core").PgUUIDBuilderInitial<string>>>> | undefined;
+                idProvider: () => string;
             };
         };
         types: {
@@ -29,9 +29,19 @@ export declare const notificationApiDefinition: {
             parameters: import("../../schema/index.js").ObjectSchema<{
                 offset?: number | undefined;
                 limit?: number | undefined;
-                after?: string | undefined;
+                after?: string | number | undefined;
                 unreadOnly?: boolean | undefined;
-                includeArchived?: boolean | undefined;
+            }>;
+            result: import("../../schema/index.js").ArraySchema<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
+            credentials: true;
+        };
+        listArchivedInApp: {
+            resource: string;
+            method: "GET";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                offset?: number | undefined;
+                limit?: number | undefined;
+                after?: string | number | undefined;
             }>;
             result: import("../../schema/index.js").ArraySchema<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
             credentials: true;
@@ -120,7 +130,7 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             };
             credentials: true;
             dataStream: {
-                idProvider: (item: NotificationStreamItem) => import("../../types/tagged.js").Tagged<string, "column", import("drizzle-orm").IsPrimaryKey<import("drizzle-orm").HasDefault<import("drizzle-orm/pg-core").PgUUIDBuilderInitial<string>>>> | undefined;
+                idProvider: () => string;
             };
         };
         types: {
@@ -135,9 +145,19 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             parameters: import("../../schema/index.js").ObjectSchema<{
                 offset?: number | undefined;
                 limit?: number | undefined;
-                after?: string | undefined;
+                after?: string | number | undefined;
                 unreadOnly?: boolean | undefined;
-                includeArchived?: boolean | undefined;
+            }>;
+            result: import("../../schema/index.js").ArraySchema<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
+            credentials: true;
+        };
+        listArchivedInApp: {
+            resource: string;
+            method: "GET";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                offset?: number | undefined;
+                limit?: number | undefined;
+                after?: string | number | undefined;
             }>;
             result: import("../../schema/index.js").ArraySchema<InAppNotificationView<Record<string, import("../models/notification-log.model.js").NotificationDefinition<import("../../types/types.js").ObjectLiteral, import("../../types/types.js").ObjectLiteral>>>>;
             credentials: true;

package/notification/api/notification.api.js

@@ -7,8 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/types.js';
 import { ReplaceClass } from '../../injector/decorators.js';
-import { array, boolean, enumeration, literal, number, object, optional, record, string } from '../../schema/index.js';
+import { array, boolean, enumeration, literal, number, object, optional, record, string, union } from '../../schema/index.js';
 import { DataStream } from '../../sse/data-stream.js';
+import { currentTimestamp } from '../../utils/date-time.js';
 import { InAppNotificationView } from '../models/in-app-notification.model.js';
 import { NotificationChannel } from '../models/index.js';
 export const notificationApiDefinition = defineApi({
@@ -20,7 +21,7 @@ export const notificationApiDefinition = defineApi({
             result: (DataStream),
             credentials: true,
             dataStream: {
-                idProvider: (item) => item.notification?.id,
+                idProvider: () => currentTimestamp().toString(),
             },
         },
         types: {
@@ -35,9 +36,19 @@ export const notificationApiDefinition = defineApi({
             parameters: object({
                 limit: optional(number()),
                 offset: optional(number()),
-                after: optional(string()),
+                after: optional(union(number(), string())),
                 unreadOnly: optional(boolean()),
-                includeArchived: optional(boolean()),
+            }),
+            result: array(InAppNotificationView),
+            credentials: true,
+        },
+        listArchivedInApp: {
+            resource: 'in-app/archived',
+            method: 'GET',
+            parameters: object({
+                limit: optional(number()),
+                offset: optional(number()),
+                after: optional(union(number(), string())),
             }),
             result: array(InAppNotificationView),
             credentials: true,

package/notification/client/notification-client.d.ts

@@ -1,5 +1,6 @@
 import { NotificationApiClient } from '../../notification/api/index.js';
 import type { InAppNotificationView, NotificationDefinitionMap } from '../../notification/models/index.js';
+import type { NotificationStreamItem } from '../../notification/types.js';
 type NotificationState<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
     notifications: InAppNotificationView<Definitions>[];
     unreadCount: number;
@@ -7,6 +8,9 @@ type NotificationState<Definitions extends NotificationDefinitionMap = Notificat
 export declare class NotificationClient<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> {
     #private;
     readonly api: NotificationApiClient;
+    readonly stream$: import("rxjs").Observable<NotificationStreamItem<Definitions>>;
+    /** Emits whenever a new notification is received via the stream. */
+    readonly onNewNotification$: import("rxjs").Observable<InAppNotificationView<Definitions>>;
     readonly state$: import("rxjs").Observable<NotificationState<Definitions>>;
     readonly notifications$: import("rxjs").Observable<InAppNotificationView<Definitions>[]>;
     readonly unreadCount$: import("rxjs").Observable<number>;
@@ -15,6 +19,8 @@ export declare class NotificationClient<Definitions extends NotificationDefiniti
     readonly notifications: import("../../signals/api.js").Signal<InAppNotificationView<Definitions>[]>;
     readonly unreadCount: import("../../signals/api.js").Signal<number>;
     readonly types: import("../../signals/api.js").Signal<Record<keyof Definitions, string>>;
+    readonly unreadNotifications: import("../../signals/api.js").Signal<InAppNotificationView<Definitions>[]>;
+    readonly readNotifications: import("../../signals/api.js").Signal<InAppNotificationView<Definitions>[]>;
     loadNext(count?: number): void;
 }
 export {};

package/notification/client/notification-client.js

@@ -4,23 +4,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { concatMap, defer, from, map, merge, of, scan, shareReplay, Subject, switchAll, switchMap } from 'rxjs';
+import { concatMap, defer, EMPTY, filter, from, map, merge, of, scan, share, shareReplay, Subject, switchAll, switchMap } from 'rxjs';
 import { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject } from '../../injector/inject.js';
 import { NotificationApiClient } from '../../notification/api/index.js';
 import { forceCast } from '../../rxjs-utils/cast.js';
 import { computed, toSignal } from '../../signals/api.js';
-import { isDefined, isUndefined } from '../../utils/type-guards.js';
+import { isDefined, isNotNull, isNull, isUndefined } from '../../utils/type-guards.js';
 let NotificationClient = class NotificationClient {
     #pagination$ = new Subject();
     #authenticationService = inject(AuthenticationClientService);
     api = inject(NotificationApiClient);
+    stream$ = this.#authenticationService.sessionId$.pipe(switchMap((sessionId) => {
+        if (isUndefined(sessionId)) {
+            return EMPTY;
+        }
+        return defer(() => from(this.api.stream())).pipe(switchAll(), forceCast());
+    }), share());
+    /** Emits whenever a new notification is received via the stream. */
+    onNewNotification$ = this.stream$.pipe(filter((item) => isDefined(item.notification)), map((item) => item.notification));
     state$ = this.#authenticationService.sessionId$.pipe(switchMap((sessionId) => {
         if (isUndefined(sessionId)) {
             return of({ notifications: [], unreadCount: 0 });
         }
-        return merge(defer(() => from(this.api.listInApp({ limit: 20 }))).pipe(map((notifications) => ({ type: 'set-notifications', notifications: notifications }))), defer(() => from(this.api.unreadCount())).pipe(map((unreadCount) => ({ type: 'set-unread-count', unreadCount }))), defer(() => from(this.api.stream())).pipe(switchAll(), forceCast(), switchMap((item) => {
+        return merge(defer(() => from(this.api.listInApp({ limit: 20 }))).pipe(map((notifications) => ({ type: 'set-notifications', notifications: notifications }))), defer(() => from(this.api.unreadCount())).pipe(map((unreadCount) => ({ type: 'set-unread-count', unreadCount }))), this.stream$.pipe(switchMap((item) => {
             const actions = [];
             if (isDefined(item.unreadCount)) {
                 actions.push({ type: 'set-unread-count', unreadCount: item.unreadCount });
@@ -90,6 +98,8 @@ let NotificationClient = class NotificationClient {
     notifications = computed(() => this.state().notifications);
     unreadCount = computed(() => this.state().unreadCount);
     types = toSignal(this.types$, { initialValue: {} });
+    unreadNotifications = computed(() => this.notifications().filter((notification) => isNull(notification.readTimestamp)));
+    readNotifications = computed(() => this.notifications().filter((notification) => isNotNull(notification.readTimestamp)));
     loadNext(count = 20) {
         const current = this.notifications();
         const after = current[current.length - 1]?.id;

package/notification/models/in-app-notification.model.d.ts

@@ -1,14 +1,20 @@
 import { TenantBaseEntity, type Uuid } from '../../orm/index.js';
 import type { Timestamp } from '../../orm/types.js';
 import { type NotificationDefinitionMap, type NotificationLogView } from './notification-log.model.js';
-export declare class InAppNotification extends TenantBaseEntity {
-    static readonly entityName = "InAppNotification";
+export declare abstract class InAppNotificationBase extends TenantBaseEntity {
     userId: Uuid;
     logId: Uuid;
+    timestamp: Timestamp;
     readTimestamp: Timestamp | null;
     archiveTimestamp: Timestamp | null;
 }
-export declare class InAppNotificationView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends InAppNotification {
+export declare class InAppNotification extends InAppNotificationBase {
+    static readonly entityName = "InAppNotification";
+}
+export declare class InAppNotificationArchive extends InAppNotificationBase {
+    static readonly entityName = "InAppNotificationArchive";
+}
+export declare class InAppNotificationView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends InAppNotificationBase {
     notification: NotificationLogView<Definitions>;
 }
 export declare function toInAppNotificationView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap>(inAppNotification: InAppNotification, notification: NotificationLogView<Definitions>): InAppNotificationView<Definitions>;

package/notification/models/in-app-notification.model.js

@@ -7,43 +7,64 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+import { isNotNull, isNull } from 'drizzle-orm';
 import { User } from '../../authentication/index.js';
-import { ForeignKey, Index, TenantBaseEntity, TenantReference, TimestampProperty, UuidProperty } from '../../orm/index.js';
+import { ForeignKey, Index, TenantBaseEntity, TenantReference, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
 import { Property } from '../../schema/index.js';
 import { NotificationLogEntity } from './notification-log.model.js';
 import { NotificationTable } from './notification-table.js';
-let InAppNotification = class InAppNotification extends TenantBaseEntity {
-    static entityName = 'InAppNotification';
+export class InAppNotificationBase extends TenantBaseEntity {
     userId;
     logId;
-    // TODO: anpinnen?
+    timestamp;
     readTimestamp;
     archiveTimestamp;
-};
+}
 __decorate([
     UuidProperty(),
     TenantReference(() => User),
     __metadata("design:type", String)
-], InAppNotification.prototype, "userId", void 0);
+], InAppNotificationBase.prototype, "userId", void 0);
 __decorate([
     UuidProperty(),
     __metadata("design:type", String)
-], InAppNotification.prototype, "logId", void 0);
+], InAppNotificationBase.prototype, "logId", void 0);
+__decorate([
+    TimestampProperty(),
+    __metadata("design:type", Number)
+], InAppNotificationBase.prototype, "timestamp", void 0);
 __decorate([
     TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
-], InAppNotification.prototype, "readTimestamp", void 0);
+], InAppNotificationBase.prototype, "readTimestamp", void 0);
 __decorate([
     TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
-], InAppNotification.prototype, "archiveTimestamp", void 0);
+], InAppNotificationBase.prototype, "archiveTimestamp", void 0);
+let InAppNotification = class InAppNotification extends InAppNotificationBase {
+    static entityName = 'InAppNotification';
+};
 InAppNotification = __decorate([
     NotificationTable({ name: 'in_app' }),
     ForeignKey(() => NotificationLogEntity, ['tenantId', 'logId', 'userId'], ['tenantId', 'id', 'userId']),
-    Index(['tenantId', 'userId', 'logId'], { where: () => ({ archiveTimestamp: null }) })
+    Unique(['tenantId', 'userId', 'logId']),
+    Index(['tenantId', 'userId', ['timestamp', 'desc'], ['logId', 'desc']]),
+    Index(['tenantId', 'userId', ['timestamp', 'desc'], ['logId', 'desc']], { where: (table) => isNull(table.readTimestamp) }),
+    Index(['tenantId', 'userId', 'readTimestamp'], { where: (table) => isNotNull(table.readTimestamp) }) // todo: include id as soon as drizzle supports this to make it a covering index for queries that fetch read notifications
+    ,
+    Index(['timestamp'], { using: 'brin' })
 ], InAppNotification);
 export { InAppNotification };
-export class InAppNotificationView extends InAppNotification {
+let InAppNotificationArchive = class InAppNotificationArchive extends InAppNotificationBase {
+    static entityName = 'InAppNotificationArchive';
+};
+InAppNotificationArchive = __decorate([
+    NotificationTable({ name: 'in_app_archive' }),
+    Index(['tenantId', 'userId', ['timestamp', 'desc'], ['logId', 'desc']]),
+    Index(['tenantId', 'userId', ['archiveTimestamp', 'desc']]) // todo: include id as soon as drizzle supports this to make it a covering index for queries that fetch archived notifications
+], InAppNotificationArchive);
+export { InAppNotificationArchive };
+export class InAppNotificationView extends InAppNotificationBase {
     notification;
 }
 __decorate([

package/notification/models/notification-log.model.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Subject, User } from '../../authentication/index.js';
 import { defineEnum } from '../../enumeration/index.js';
-import { Index, JsonProperty, Reference, TenantBaseEntity, TenantReference, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
+import { JsonProperty, Reference, TenantBaseEntity, TenantReference, TimestampProperty, Unique, UuidProperty } from '../../orm/index.js';
 import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
 import { NotificationTable } from './notification-table.js';
 import { NotificationType } from './notification-type.model.js';
@@ -79,7 +79,6 @@ __decorate([
 ], NotificationLogEntity.prototype, "payload", void 0);
 NotificationLogEntity = __decorate([
     NotificationTable({ name: 'log' }),
-    Unique(['tenantId', 'id', 'userId']),
-    Index(['tenantId', 'userId', 'timestamp'])
+    Unique(['tenantId', 'userId', 'id'])
 ], NotificationLogEntity);
 export { NotificationLogEntity };

package/notification/server/api/notification.api-controller.d.ts

@@ -10,6 +10,7 @@ export declare class NotificationApiController implements ApiController<Notifica
     stream({ abortSignal, getToken, serverSentEvents: { lastEventId } }: ApiRequestContext<NotificationApiDefinition, 'stream'>): ApiServerResult<NotificationApiDefinition, 'stream'>;
     types(): Promise<Record<string, string>>;
     listInApp({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'listInApp'>): Promise<any>;
+    listArchivedInApp({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'listArchivedInApp'>): Promise<any>;
     markRead({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'markRead'>): Promise<'ok'>;
     markAllRead({ getToken }: ApiRequestContext<NotificationApiDefinition, 'markAllRead'>): Promise<'ok'>;
     archive({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'archive'>): Promise<'ok'>;

package/notification/server/api/notification.api-controller.js

@@ -24,7 +24,9 @@ let NotificationApiController = class NotificationApiController {
         abortSignal.addEventListener('abort', () => this.sseService.unregister(token.payload.tenant, token.payload.subject, source));
         try {
             if (isDefined(lastEventId)) {
-                const { unreadCount, missedNotifications, readIds, archiveIds } = await this.notificationService.getCatchupData(token.payload.tenant, token.payload.subject, lastEventId);
+                const lastEventIdNumber = Number(lastEventId);
+                const stateTimestamp = Number.isNaN(lastEventIdNumber) ? 0 : lastEventIdNumber;
+                const { unreadCount, missedNotifications, readIds, archiveIds } = await this.notificationService.getCatchupData(token.payload.tenant, token.payload.subject, stateTimestamp);
                 yield { unreadCount };
                 for (const readId of readIds) {
                     yield { readId };
@@ -49,6 +51,10 @@ let NotificationApiController = class NotificationApiController {
         const token = await getToken();
         return await this.notificationService.listInApp(token.payload.tenant, token.payload.subject, parameters);
     }
+    async listArchivedInApp({ parameters, getToken }) {
+        const token = await getToken();
+        return await this.notificationService.listArchivedInApp(token.payload.tenant, token.payload.subject, parameters);
+    }
     async markRead({ parameters, getToken }) {
         const token = await getToken();
         await this.notificationService.markRead(token.payload.tenant, token.payload.subject, parameters.id);

package/notification/server/drizzle/{0000_oval_rage.sql → 0000_wise_pyro.sql}

@@ -6,9 +6,22 @@ CREATE TABLE "notification"."in_app" (
 	"tenant_id" uuid NOT NULL,
 	"user_id" uuid NOT NULL,
 	"log_id" uuid NOT NULL,
+	"timestamp" timestamp with time zone NOT NULL,
+	"read_timestamp" timestamp with time zone,
+	"archive_timestamp" timestamp with time zone,
+	CONSTRAINT "in_app_tenant_id_id_pk" PRIMARY KEY("tenant_id","id"),
+	CONSTRAINT "in_app_tenant_id_user_id_log_id_unique" UNIQUE("tenant_id","user_id","log_id")
+);
+--> statement-breakpoint
+CREATE TABLE "notification"."in_app_archive" (
+	"id" uuid DEFAULT gen_random_uuid() NOT NULL,
+	"tenant_id" uuid NOT NULL,
+	"user_id" uuid NOT NULL,
+	"log_id" uuid NOT NULL,
+	"timestamp" timestamp with time zone NOT NULL,
 	"read_timestamp" timestamp with time zone,
 	"archive_timestamp" timestamp with time zone,
-	CONSTRAINT "in_app_tenant_id_id_pk" PRIMARY KEY("tenant_id","id")
+	CONSTRAINT "in_app_archive_tenant_id_id_pk" PRIMARY KEY("tenant_id","id")
 );
 --> statement-breakpoint
 CREATE TABLE "notification"."log" (
@@ -23,7 +36,7 @@ CREATE TABLE "notification"."log" (
 	"trigger_subject_id" uuid NOT NULL,
 	"payload" jsonb,
 	CONSTRAINT "log_tenant_id_id_pk" PRIMARY KEY("tenant_id","id"),
-	CONSTRAINT "log_tenant_id_id_user_id_unique" UNIQUE("tenant_id","id","user_id")
+	CONSTRAINT "log_tenant_id_user_id_id_unique" UNIQUE("tenant_id","user_id","id")
 );
 --> statement-breakpoint
 CREATE TABLE "notification"."preference" (
@@ -74,11 +87,16 @@ CREATE TABLE "notification"."web_push_subscription" (
 --> statement-breakpoint
 ALTER TABLE "notification"."in_app" ADD CONSTRAINT "in_app_id_user_fkey" FOREIGN KEY ("tenant_id","user_id") REFERENCES "authentication"."user"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."in_app" ADD CONSTRAINT "in_app_tenantId_logId_userId_log_fkey" FOREIGN KEY ("tenant_id","log_id","user_id") REFERENCES "notification"."log"("tenant_id","id","user_id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "notification"."in_app_archive" ADD CONSTRAINT "in_app_archive_id_user_fkey" FOREIGN KEY ("tenant_id","user_id") REFERENCES "authentication"."user"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."log" ADD CONSTRAINT "log_type_type_key_fk" FOREIGN KEY ("type") REFERENCES "notification"."type"("key") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."log" ADD CONSTRAINT "log_id_user_fkey" FOREIGN KEY ("tenant_id","user_id") REFERENCES "authentication"."user"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."log" ADD CONSTRAINT "log_id_subject_fkey" FOREIGN KEY ("tenant_id","trigger_subject_id") REFERENCES "authentication"."subject"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."preference" ADD CONSTRAINT "preference_type_type_key_fk" FOREIGN KEY ("type") REFERENCES "notification"."type"("key") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."preference" ADD CONSTRAINT "preference_id_user_fkey" FOREIGN KEY ("tenant_id","user_id") REFERENCES "authentication"."user"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "notification"."web_push_subscription" ADD CONSTRAINT "web_push_subscription_id_user_fkey" FOREIGN KEY ("tenant_id","user_id") REFERENCES "authentication"."user"("tenant_id","id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-CREATE INDEX "in_app_tenant_id_user_id_log_id_idx" ON "notification"."in_app" USING btree ("tenant_id","user_id","log_id") WHERE "notification"."in_app"."archive_timestamp" is null;--> statement-breakpoint
-CREATE INDEX "log_tenant_id_user_id_timestamp_idx" ON "notification"."log" USING btree ("tenant_id","user_id","timestamp");
+CREATE INDEX "in_app_timestamp_idx" ON "notification"."in_app" USING brin ("timestamp");--> statement-breakpoint
+CREATE INDEX "in_app_tenant_id_user_id_read_timestamp_partial_idx" ON "notification"."in_app" USING btree ("tenant_id","user_id","read_timestamp") WHERE "notification"."in_app"."read_timestamp" is not null;--> statement-breakpoint
+CREATE INDEX "in_app_tenant_id_user_id_timestamp_log_id_partial_idx" ON "notification"."in_app" USING btree ("tenant_id","user_id","timestamp" DESC NULLS LAST,"log_id" DESC NULLS LAST) WHERE "notification"."in_app"."read_timestamp" is null;--> statement-breakpoint
+CREATE INDEX "in_app_tenant_id_user_id_timestamp_log_id_idx" ON "notification"."in_app" USING btree ("tenant_id","user_id","timestamp" DESC NULLS LAST,"log_id" DESC NULLS LAST);--> statement-breakpoint
+CREATE INDEX "in_app_archive_tenant_id_user_id_archive_timestamp_idx" ON "notification"."in_app_archive" USING btree ("tenant_id","user_id","archive_timestamp" DESC NULLS LAST);--> statement-breakpoint
+CREATE INDEX "in_app_archive_tenant_id_user_id_timestamp_log_id_idx" ON "notification"."in_app_archive" USING btree ("tenant_id","user_id","timestamp" DESC NULLS LAST,"log_id" DESC NULLS LAST);