@tstdl/base 0.93.107 → 0.93.109

package/data-structures/collection.d.ts

@@ -1,6 +1,6 @@
 import { type Observable } from 'rxjs';
 import type { ToJson } from '../interfaces.js';
-import { type Signal } from '../signals/index.js';
+import { type Signal } from '../signals/api.js';
 export declare abstract class Collection<T, TItemsIterator extends IterableIterator<any>, TThis extends Collection<T, TItemsIterator, TThis> = Collection<T, TItemsIterator, any>> implements Iterable<T>, ToJson {
     private readonly sizeSubject;
     private readonly changeSubject;

package/data-structures/collection.js

@@ -1,5 +1,6 @@
 import { BehaviorSubject, Subject, distinctUntilChanged, filter, firstValueFrom, map, startWith } from 'rxjs';
-import { toLazySignal, untracked } from '../signals/index.js';
+import { untracked } from '../signals/api.js';
+import { toLazySignal } from '../signals/to-lazy-signal.js';
 import { lazyProperty } from '../utils/object/lazy-property.js';
 export class Collection {
     sizeSubject = new BehaviorSubject(0);

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

@@ -40,7 +40,7 @@ __decorate([
 InAppNotification = __decorate([
     NotificationTable({ name: 'in_app' }),
     ForeignKey(() => NotificationLogEntity, ['tenantId', 'logId', 'userId'], ['tenantId', 'id', 'userId']),
-    Index(['tenantId', 'userId', 'readTimestamp', 'archiveTimestamp'])
+    Index(['tenantId', 'userId', 'logId'], { where: () => ({ archiveTimestamp: null }) })
 ], InAppNotification);
 export { InAppNotification };
 export class InAppNotificationView extends InAppNotification {

package/notification/models/notification-log.model.d.ts

@@ -1,5 +1,6 @@
+import type { Merge } from 'type-fest';
 import { type EnumType } from '../../enumeration/index.js';
-import { type Json, TenantEntity, type Uuid } from '../../orm/index.js';
+import { type Json, TenantBaseEntity, type Timestamp, type Uuid } from '../../orm/index.js';
 import type { ObjectLiteral } from '../../types/types.js';
 export declare const NotificationChannel: {
     readonly InApp: "in-app";
@@ -44,19 +45,17 @@ export type NotificationLog<Definitions extends NotificationDefinitionMap = Noti
 export type NotificationLogView<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
     [Type in NotificationTypes<Definitions>]: Omit<NotificationLogEntity<Definitions, Type>, 'type' | 'payload'> & {
         type: Type;
-        payload: NotificationPayload<Definitions, Type>;
-        view: NotificationView<Definitions, Type>;
+        payload: Merge<NotificationPayload<Definitions, Type>, NotificationView<Definitions, Type>>;
     };
 }[NotificationTypes<Definitions>];
-export declare class NotificationLogEntity<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> extends TenantEntity {
+export declare class NotificationLogEntity<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> extends TenantBaseEntity {
     static readonly entityName = "NotificationLog";
     userId: Uuid;
     type: Type;
+    timestamp: Timestamp;
     priority: NotificationPriority;
     status: NotificationStatus;
     currentStep: number;
+    triggerSubjectId: Uuid;
     payload: Json<NotificationPayload<Definitions, Type>> | null;
 }
-export declare class NotificationLogViewEntity<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap, Type extends NotificationTypes<Definitions> = NotificationTypes<Definitions>> extends NotificationLogEntity<Definitions, Type> {
-    view?: unknown;
-}

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

@@ -7,10 +7,10 @@ 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 { User } from '../../authentication/models/user.model.js';
+import { Subject, User } from '../../authentication/index.js';
 import { defineEnum } from '../../enumeration/index.js';
-import { JsonProperty, Reference, TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
-import { Enumeration, Integer, StringProperty, Unknown } from '../../schema/index.js';
+import { Index, 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';
 export const NotificationChannel = defineEnum('NotificationChannel', {
@@ -31,13 +31,15 @@ export const NotificationStatus = defineEnum('NotificationStatus', {
     Read: 'read',
     Failed: 'failed',
 });
-let NotificationLogEntity = class NotificationLogEntity extends TenantEntity {
+let NotificationLogEntity = class NotificationLogEntity extends TenantBaseEntity {
     static entityName = 'NotificationLog';
     userId;
     type;
+    timestamp;
     priority;
     status;
     currentStep;
+    triggerSubjectId;
     payload;
 };
 __decorate([
@@ -50,6 +52,10 @@ __decorate([
     StringProperty(),
     __metadata("design:type", String)
 ], NotificationLogEntity.prototype, "type", void 0);
+__decorate([
+    TimestampProperty(),
+    __metadata("design:type", Number)
+], NotificationLogEntity.prototype, "timestamp", void 0);
 __decorate([
     Enumeration(NotificationPriority),
     __metadata("design:type", String)
@@ -62,19 +68,18 @@ __decorate([
     Integer(),
     __metadata("design:type", Number)
 ], NotificationLogEntity.prototype, "currentStep", void 0);
+__decorate([
+    TenantReference(() => Subject),
+    UuidProperty(),
+    __metadata("design:type", String)
+], NotificationLogEntity.prototype, "triggerSubjectId", void 0);
 __decorate([
     JsonProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], NotificationLogEntity.prototype, "payload", void 0);
 NotificationLogEntity = __decorate([
     NotificationTable({ name: 'log' }),
-    Unique(['tenantId', 'id', 'userId'])
+    Unique(['tenantId', 'id', 'userId']),
+    Index(['tenantId', 'userId', 'timestamp'])
 ], NotificationLogEntity);
 export { NotificationLogEntity };
-export class NotificationLogViewEntity extends NotificationLogEntity {
-    view;
-}
-__decorate([
-    Unknown(),
-    __metadata("design:type", Object)
-], NotificationLogViewEntity.prototype, "view", void 0);

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

@@ -16,15 +16,12 @@ CREATE TABLE "notification"."log" (
 	"tenant_id" uuid NOT NULL,
 	"user_id" uuid NOT NULL,
 	"type" text NOT NULL,
+	"timestamp" timestamp with time zone NOT NULL,
 	"priority" "notification"."notification_priority" NOT NULL,
 	"status" "notification"."notification_status" NOT NULL,
 	"current_step" integer NOT NULL,
+	"trigger_subject_id" uuid NOT NULL,
 	"payload" jsonb,
-	"revision" integer NOT NULL,
-	"revision_timestamp" timestamp with time zone NOT NULL,
-	"create_timestamp" timestamp with time zone NOT NULL,
-	"delete_timestamp" timestamp with time zone,
-	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
 	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")
 );
@@ -79,7 +76,9 @@ ALTER TABLE "notification"."in_app" ADD CONSTRAINT "in_app_id_user_fkey" FOREIGN
 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"."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_read_timestamp_archive_timestamp_idx" ON "notification"."in_app" USING btree ("tenant_id","user_id","read_timestamp","archive_timestamp");
+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");

package/notification/server/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "7751e29f-1334-4511-8bf5-0d0f2550b5ae",
+  "id": "90cd6144-d455-4a13-8148-ca119f8bfe79",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -47,8 +47,8 @@
         }
       },
       "indexes": {
-        "in_app_tenant_id_user_id_read_timestamp_archive_timestamp_idx": {
-          "name": "in_app_tenant_id_user_id_read_timestamp_archive_timestamp_idx",
+        "in_app_tenant_id_user_id_log_id_idx": {
+          "name": "in_app_tenant_id_user_id_log_id_idx",
           "columns": [
             {
               "expression": "tenant_id",
@@ -63,19 +63,14 @@
               "nulls": "last"
             },
             {
-              "expression": "read_timestamp",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "archive_timestamp",
+              "expression": "log_id",
               "isExpression": false,
               "asc": true,
               "nulls": "last"
             }
           ],
           "isUnique": false,
+          "where": "\"notification\".\"in_app\".\"archive_timestamp\" is null",
           "concurrently": false,
           "method": "btree",
           "with": {}
@@ -160,6 +155,12 @@
           "primaryKey": false,
           "notNull": true
         },
+        "timestamp": {
+          "name": "timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
         "priority": {
           "name": "priority",
           "type": "notification_priority",
@@ -180,45 +181,48 @@
           "primaryKey": false,
           "notNull": true
         },
-        "payload": {
-          "name": "payload",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "revision": {
-          "name": "revision",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "revision_timestamp": {
-          "name": "revision_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "create_timestamp": {
-          "name": "create_timestamp",
-          "type": "timestamp with time zone",
+        "trigger_subject_id": {
+          "name": "trigger_subject_id",
+          "type": "uuid",
           "primaryKey": false,
           "notNull": true
         },
-        "delete_timestamp": {
-          "name": "delete_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "attributes": {
-          "name": "attributes",
+        "payload": {
+          "name": "payload",
           "type": "jsonb",
           "primaryKey": false,
-          "notNull": true,
-          "default": "'{}'::jsonb"
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "log_tenant_id_user_id_timestamp_idx": {
+          "name": "log_tenant_id_user_id_timestamp_idx",
+          "columns": [
+            {
+              "expression": "tenant_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "timestamp",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
         }
       },
-      "indexes": {},
       "foreignKeys": {
         "log_type_type_key_fk": {
           "name": "log_type_type_key_fk",
@@ -249,6 +253,22 @@
           ],
           "onDelete": "no action",
           "onUpdate": "no action"
+        },
+        "log_id_subject_fkey": {
+          "name": "log_id_subject_fkey",
+          "tableFrom": "log",
+          "tableTo": "subject",
+          "schemaTo": "authentication",
+          "columnsFrom": [
+            "tenant_id",
+            "trigger_subject_id"
+          ],
+          "columnsTo": [
+            "tenant_id",
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
         }
       },
       "compositePrimaryKeys": {

package/notification/server/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1770118617281,
-      "tag": "0000_ancient_hellion",
+      "when": 1770233636064,
+      "tag": "0000_oval_rage",
       "breakpoints": true
     }
   ]

package/notification/server/services/notification-delivery.worker.js

@@ -80,7 +80,7 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
                 for (const channel of enabledChannels) {
                     // TODO: what if an error occurs here? partial delivery? Should we use tasks to allow retrying individual channels?
                     const [viewData] = await this.#notificationAncillaryService.getViewData([notification]);
-                    await this.sendToChannel({ ...notification, view: viewData }, channel, tx);
+                    await this.sendToChannel({ ...notification, payload: { ...notification.payload, ...viewData } }, channel, tx);
                 }
                 await this.#notificationLogRepository.withTransaction(tx).update(notificationId, { status: NotificationStatus.Sent, currentStep: 1 });
                 if (isNotNull(type.escalations) && (type.escalations.length > 0)) {
@@ -99,7 +99,7 @@ let NotificationDeliveryWorker = class NotificationDeliveryWorker extends Transa
                     return TaskProcessResult.Complete();
                 }
                 const [viewData] = await this.#notificationAncillaryService.getViewData([notification]);
-                await this.sendToChannel({ ...notification, view: viewData }, rule.channel, tx);
+                await this.sendToChannel({ ...notification, payload: { ...notification.payload, ...viewData } }, rule.channel, tx);
                 await this.#notificationLogRepository.withTransaction(tx).update(notificationId, { currentStep: step + 1 });
                 if (step < type.escalations.length) {
                     const nextRule = type.escalations[step];

package/notification/server/services/notification.service.d.ts

@@ -4,7 +4,7 @@ import type { TypedOmit } from '../../../types/types.js';
 import { NotificationPreference, type InAppNotificationView, type NotificationChannel, type NotificationDefinitionMap, type NotificationLog } from '../../models/index.js';
 export declare class NotificationService<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> extends Transactional {
     #private;
-    send(tenantId: string, userId: string, notification: TypedOmit<NewEntity<NotificationLog<Definitions>>, 'tenantId' | 'id' | 'userId' | 'status' | 'currentStep' | 'priority' | 'metadata'> & Partial<Pick<NotificationLog<Definitions>, 'priority'>>): Promise<void>;
+    send(tenantId: string, userId: string, notification: TypedOmit<NewEntity<NotificationLog<Definitions>>, 'tenantId' | 'id' | 'userId' | 'timestamp' | 'status' | 'currentStep' | 'priority'> & Partial<Pick<NotificationLog<Definitions>, 'priority'>>): Promise<void>;
     listInApp(tenantId: string, userId: string, options?: {
         limit?: number;
         offset?: number;

package/notification/server/services/notification.service.js

@@ -25,6 +25,7 @@ let NotificationService = class NotificationService extends Transactional {
             const notificationToInsert = {
                 tenantId,
                 userId,
+                timestamp: TRANSACTION_TIMESTAMP,
                 priority: NotificationPriority.Medium,
                 ...notification,
                 status: NotificationStatus.Pending,
@@ -41,11 +42,11 @@ let NotificationService = class NotificationService extends Transactional {
             inApp: inAppNotification,
         })
             .from(notificationLog)
-            .innerJoin(inAppNotification, eq(inAppNotification.logId, notificationLog.id))
-            .where(and(eq(inAppNotification.tenantId, tenantId), eq(notificationLog.userId, userId), options.includeArchived ? undefined : isNull(inAppNotification.archiveTimestamp)))
+            .innerJoin(inAppNotification, and(eq(inAppNotification.tenantId, notificationLog.tenantId), eq(inAppNotification.userId, notificationLog.userId), eq(inAppNotification.logId, notificationLog.id)))
+            .where(and(eq(notificationLog.tenantId, tenantId), eq(notificationLog.userId, userId), options.includeArchived ? undefined : isNull(inAppNotification.archiveTimestamp)))
             .limit(options.limit ?? 50)
             .offset(options.offset ?? 0)
-            .orderBy(desc(notificationLog.createTimestamp));
+            .orderBy(desc(notificationLog.timestamp));
         const inAppRows = rows.map((row) => row.inApp);
         const notificationRows = rows.map((row) => row.notification);
         const notificationEntities = await this.#notificationLogRepository.mapManyToEntity(notificationRows);
@@ -54,7 +55,8 @@ let NotificationService = class NotificationService extends Transactional {
         const views = notificationEntities.map((notification, index) => {
             const inApp = inAppEntities[index];
             const viewData = notificationViewDatas[index];
-            return toInAppNotificationView(inApp, { ...notification, view: viewData });
+            const payload = { ...notification.payload, ...viewData };
+            return toInAppNotificationView(inApp, { ...notification, payload });
         });
         return views;
     }

package/notification/tests/notification-flow.test.js

@@ -86,6 +86,7 @@ describe('Notification Flow (Integration)', () => {
             await notificationService.send(tenantId, user.id, {
                 type: 'test',
                 priority: 'high',
+                triggerSubjectId: user.id,
                 payload: { message: 'Hello', testField: 'Test Value' },
             });
             const logs = await logRepo.loadManyByQuery({ tenantId });
@@ -123,13 +124,13 @@ describe('Notification Flow (Integration)', () => {
                 },
             });
             await notificationService.send(tenantId, user.id, {
-                type: 'throttled', priority: 'medium', payload: {},
+                type: 'throttled', priority: 'medium', triggerSubjectId: user.id, payload: {},
             });
             await notificationService.send(tenantId, user.id, {
-                type: 'throttled', priority: 'medium', payload: {},
+                type: 'throttled', priority: 'medium', triggerSubjectId: user.id, payload: {},
             });
             const logs = await logRepo.loadManyByQuery({ tenantId });
-            logs.sort((a, b) => Number(a.metadata.createTimestamp) - Number(b.metadata.createTimestamp));
+            logs.sort((a, b) => Number(a.timestamp) - Number(b.timestamp));
             // First one should pass
             const result1 = await worker.deliver(logs[0].id);
             expect(result1.payload.action).toBe('complete'); // No escalations
@@ -149,7 +150,7 @@ describe('Notification Flow (Integration)', () => {
                 },
             });
             await notificationService.send(tenantId, user.id, {
-                type: 'readTest', priority: 'medium', payload: {},
+                type: 'readTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
             });
             const logs = await logRepo.loadManyByQuery({ tenantId });
             const log = logs[0];
@@ -176,7 +177,7 @@ describe('Notification Flow (Integration)', () => {
             await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.InApp, false);
             await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.Email, true);
             await notificationService.send(tenantId, user.id, {
-                type: 'prefTest', priority: 'medium', payload: {},
+                type: 'prefTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
             });
             const logs = await logRepo.loadManyByQuery({ tenantId });
             const log = logs[0];
@@ -201,7 +202,7 @@ describe('Notification Flow (Integration)', () => {
             // Disable InApp so only WebPush is attempted
             await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.InApp, false);
             await notificationService.send(tenantId, user.id, {
-                type: 'unknownTest', priority: 'medium', payload: {},
+                type: 'unknownTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
             });
             const logs = await logRepo.loadManyByQuery({ tenantId });
             const log = logs[0];
@@ -218,7 +219,7 @@ describe('Notification Flow (Integration)', () => {
             const user = await subjectService.createUser({ tenantId, email: 'manage@example.com', firstName: 'Manage', lastName: 'User' });
             await typeService.initializeTypes({ manageTest: { label: 'Manage Test' } });
             await notificationService.send(tenantId, user.id, {
-                type: 'manageTest', priority: 'medium', payload: {},
+                type: 'manageTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
             });
             const logs = await logRepo.loadManyByQuery({ tenantId });
             await worker.deliver(logs[0].id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.107",
+  "version": "0.93.109",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -101,8 +101,6 @@
     "./pool": "./pool/index.js",
     "./process": "./process/index.js",
     "./promise": "./promise/index.js",
-    "./task-queue": "./task-queue/index.js",
-    "./task-queue/postgres": "./task-queue/postgres/index.js",
     "./random": "./random/index.js",
     "./rate-limit": "./rate-limit/index.js",
     "./rate-limit/postgres": "./rate-limit/postgres/index.js",
@@ -120,6 +118,8 @@
     "./signals": "./signals/index.js",
     "./signals/implementation": "./signals/implementation/index.js",
     "./sse": "./sse/index.js",
+    "./task-queue": "./task-queue/index.js",
+    "./task-queue/postgres": "./task-queue/postgres/index.js",
     "./templates": "./templates/index.js",
     "./templates/providers": "./templates/providers/index.js",
     "./templates/renderers": "./templates/renderers/index.js",
@@ -128,6 +128,7 @@
     "./text": "./text/index.js",
     "./threading": "./threading/index.js",
     "./types": "./types/index.js",
+    "./typst": "./typst/index.js",
     "./unit-test": "./unit-test/index.js",
     "./utils": "./utils/index.js",
     "./utils/array": "./utils/array/index.js",

package/process/spawn.d.ts

@@ -1,5 +1,5 @@
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
-import type { Record } from '../types/types.js';
+import type { Record, TypedOmit } from '../types/types.js';
 type WaitReadResultFormat = 'string' | 'binary';
 type WaitReadResultFormatType<T extends WaitReadResultFormat> = T extends 'string' ? string : Uint8Array<ArrayBuffer>;
 export type WaitOptions = {
@@ -35,9 +35,9 @@ export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
 export declare function spawnWaitCommand(command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<WaitResult>;
 export declare function spawnWaitCommand(command: string, options?: SpawnOptions & WaitOptions): Promise<WaitResult>;
 /** spwans a command, waits for it to complete and reads its output */
-export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<WaitReadResult<F>>;
+export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, args?: string[], options?: TypedOmit<SpawnOptions, 'arguments'> & WaitOptions): Promise<WaitReadResult<F>>;
 export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, options?: SpawnOptions & WaitOptions): Promise<WaitReadResult<F>>;
 /** Spawns a command as a child process. */
-export declare function spawnCommand(command: string, args?: string[], options?: SpawnOptions): Promise<SpawnCommandResult>;
+export declare function spawnCommand(command: string, args?: string[], options?: TypedOmit<SpawnOptions, 'arguments'>): Promise<SpawnCommandResult>;
 export declare function spawnCommand(command: string, options?: SpawnOptions): Promise<SpawnCommandResult>;
 export {};

package/process/spawn.js

@@ -10,7 +10,7 @@ export async function spawnWaitCommand(command, argsOrOptions, optionsOrNothing)
     return await process.wait({ throwOnNonZeroExitCode: options?.throwOnNonZeroExitCode });
 }
 export async function spawnWaitReadCommand(format, command, argsOrOptions, optionsOrNothing) {
-    const [args, options] = isArray(argsOrOptions) ? [argsOrOptions, optionsOrNothing] : [undefined, argsOrOptions];
+    const [args, options] = isArray(argsOrOptions) ? [argsOrOptions, optionsOrNothing] : [argsOrOptions?.arguments, argsOrOptions];
     const process = await spawnCommand(command, args, options);
     return await process.waitRead(format, { throwOnNonZeroExitCode: options?.throwOnNonZeroExitCode });
 }

package/task-queue/postgres/task-queue.d.ts

@@ -116,6 +116,7 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
+    notify(): void;
     getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];

package/task-queue/postgres/task-queue.js

@@ -60,6 +60,7 @@ import { and, asc, count, eq, gt, gte, inArray, lt, lte, notInArray, or, sql, is
 import { merge } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
+import { serializeError } from '../../errors/index.js';
 import { afterResolve, inject, provide, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
@@ -69,7 +70,6 @@ import { RateLimiter } from '../../rate-limit/index.js';
 import { createArray, distinct, toArray } from '../../utils/array/array.js';
 import { digest } from '../../utils/cryptography.js';
 import { currentTimestamp } from '../../utils/date-time.js';
-import { serializeError } from '../../errors/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { isDefined, isNotNull, isNull, isString, isUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
@@ -987,6 +987,9 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.id, id), or(eq(taskTable.status, TaskStatus.Pending), eq(taskTable.status, TaskStatus.Completed), eq(taskTable.status, TaskStatus.Cancelled), eq(taskTable.status, TaskStatus.Dead), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))))
             .execute();
     }
+    notify() {
+        this.#messageBus.publishAndForget();
+    }
     async *getConsumer(cancellationSignal, options) {
         const continue$ = merge(this.#messageBus.allMessages$, cancellationSignal);
         while (cancellationSignal.isUnset) {

package/task-queue/task-context.d.ts

@@ -16,6 +16,7 @@ export declare class TaskContext<Definitions extends TaskDefinitionMap, Type ext
     get state(): TaskState<Definitions, Type> | null;
     get attempt(): number;
     get triesLeft(): number;
+    get isFinalAttempt(): boolean;
     get signal(): CancellationSignal;
     get logger(): Logger;
     complete(result?: TaskResult<Definitions, Type>, options?: {

package/task-queue/task-context.js

@@ -42,6 +42,9 @@ export class TaskContext {
     get triesLeft() {
         return this.#queue.maxTries - this.#task.tries;
     }
+    get isFinalAttempt() {
+        return this.triesLeft <= 0;
+    }
     get signal() {
         return this.#signal.signal;
     }

package/task-queue/task-queue.d.ts

@@ -285,6 +285,13 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         resetState?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
+    /**
+     * Notifies the queue that new tasks might be available for processing.
+     * Used to wake up waiting consumers.
+     * Useful for unit tests.
+     * @internal
+     */
+    abstract notify(): void;
     abstract getConsumer<Type extends TaskTypes<Definitions>>(cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];

package/task-queue/tests/worker.test.js

@@ -139,4 +139,33 @@ describe('Worker & Base Class Tests', () => {
         token.set();
         expect(executed).toBe(true);
     });
+    it('should correctly report isFinalAttempt in TaskContext', async () => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `final-try-test-${Date.now()}`;
+        const testQueue = queueProvider.get(queueName, {
+            maxTries: 2,
+            retryDelayMinimum: 0,
+            retryDelayGrowth: 1,
+        });
+        await testQueue.enqueue('work', {});
+        testQueue.notify();
+        const token = new CancellationToken();
+        const finalAttemptValues = [];
+        testQueue.process({ cancellationSignal: token }, async (context) => {
+            finalAttemptValues.push(context.isFinalAttempt);
+            if (context.attempt === 1) {
+                throw new Error('fail first attempt');
+            }
+            return TaskProcessResult.Complete();
+        });
+        for (let i = 0; i < 100; i++) {
+            if (finalAttemptValues.length === 2)
+                break;
+            testQueue.notify();
+            await timeout(100);
+        }
+        token.set();
+        expect(finalAttemptValues).toEqual([false, true]);
+        await testQueue.clear();
+    });
 });

package/test5.d.ts

@@ -1,13 +1 @@
 import './polyfills.js';
-import type { NotificationDefinitionMap } from './notification/index.js';
-export type Notifications = NotificationDefinitionMap<{
-    'analysis-started': {
-        payload: {
-            analysisId: string;
-        };
-        view: {
-            name: string;
-        };
-    };
-    'analysis-completed': Record<never, never>;
-}>;

package/test5.js

@@ -1,24 +1,20 @@
 import './polyfills.js';
+import { writeFile } from 'node:fs/promises';
 import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/index.js';
-import { inject } from './injector/inject.js';
-import { JsonLogFormatter, PrettyPrintLogFormatter } from './logger/index.js';
+import { PrettyPrintLogFormatter } from './logger/index.js';
 import { provideConsoleLogTransport } from './logger/transports/console.js';
-import { NotificationService } from './notification/server/index.js';
+import { renderTypst } from './typst/render.js';
+const template = `
+I got an ice cream for
+\\$1.50! \\u{1f600}
+`;
 async function main(_cancellationSignal) {
-    const notificationService = inject((NotificationService));
-    const notificationApi = new null();
-    const notification$ = (await notificationApi.stream());
-    const tenantId = 'test-tenant';
-    const userId = 'user-123';
-    await notificationService.send(tenantId, userId, {
-        type: 'analysis-started',
-        payload: { analysisId: 'analysis-456' },
-    });
+    const pdfBytes = await renderTypst(template, { format: 'docx' });
+    await writeFile('/tmp/output.docx', pdfBytes);
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),
-    provideConsoleLogTransport(JsonLogFormatter),
     provideModule(main),
     provideSignalHandler(),
 ]);

package/typst/index.d.ts

@@ -0,0 +1 @@
+export * from './render.js';

package/typst/index.js

@@ -0,0 +1 @@
+export * from './render.js';

package/typst/render.d.ts

@@ -0,0 +1,23 @@
+export type TypstRenderOptions = {
+    /**
+     * The root directory for resolving imports in the Typst source. If not specified, imports will be resolved relative to the location of the source file.
+     */
+    root?: string;
+    /**
+     * The output format for the rendered document.
+     * Note: `docx` output uses pandoc under the hood, which does not support all Typst features.
+     * @default 'pdf'
+     */
+    format?: 'pdf' | 'png' | 'svg' | 'html' | 'docx';
+};
+/**
+ * Renders Typst source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted typst source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires typst to be installed on the system.
+ * @param source
+ * @param options
+ */
+export declare function renderTypst(source: string, options?: TypstRenderOptions): Promise<Uint8Array>;

package/typst/render.js

@@ -0,0 +1,32 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+/**
+ * Renders Typst source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted typst source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires typst to be installed on the system.
+ * @param source
+ * @param options
+ */
+export async function renderTypst(source, options) {
+    const format = options?.format ?? 'pdf';
+    const command = (format == 'docx') ? 'pandoc' : 'typst';
+    const args = (format == 'docx')
+        ? ['--from', 'typst', '--to', 'docx', '--output', '-', '-']
+        : ['compile', '--format', format, '-', '-'];
+    const process = await spawnCommand(command, args);
+    const [{ code, output, error }] = await Promise.all([
+        process.waitRead('binary', { throwOnNonZeroExitCode: false }),
+        process.write(source),
+    ]);
+    const errorString = decodeText(error);
+    if (code !== 0) {
+        throw new Error(`
+Typst compilation failed with exit code ${code}.\n
+Error Output:\n${errorString}
+`.trim());
+    }
+    return output;
+}