@tstdl/base 0.93.198 → 0.93.200

package/orm/schemas/json.js

@@ -1,6 +1,6 @@
 import { createDecorator } from '../../reflection/index.js';
 import { any, Class, object, Property, Schema, schemaTestableToSchema } from '../../schema/index.js';
-import { isDefined } from '../../utils/type-guards.js';
+import { isDefined, isUndefined } from '../../utils/type-guards.js';
 export class JsonSchema extends Schema {
     name = 'Json';
     innerSchema;
@@ -21,6 +21,7 @@ export function JsonProperty(options) {
         if (data.type == 'class') {
             return Class({ schema: json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: { type: data.constructor } }) }) })(args[0]);
         }
-        return Property(json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: { type: metadata.type } }) }), optionsRest)(args[0], args[1], args[2]);
+        const propertyType = metadata.type;
+        return Property(json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: isUndefined(propertyType) ? undefined : { type: propertyType } }) }), optionsRest)(args[0], args[1], args[2]);
     });
 }

package/orm/server/drizzle/schema-converter.js

@@ -379,7 +379,8 @@ function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath
             assertDefined(propertyMetadata, `Property "${property}" of type "${type.name}" does not have reflection metadata (path: ${path.toString()}).`);
             const propertyPrefix = columnReflectionData?.embedded?.prefix;
             const nestedPrefix = [prefix, isNull(propertyPrefix) ? '' : propertyPrefix ?? `${columnName}_`].join('');
-            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, dbSchema, tableName, path.add(property), nestedPrefix, { ...options, inherited, table }, rootType);
+            const entryType = columnReflectionData?.embedded?.type ?? assertDefinedPass(propertyMetadata.type, 'Missing type for embedded property.');
+            return getPostgresColumnEntries(entryType, dbSchema, tableName, path.add(property), nestedPrefix, { ...options, inherited, table }, rootType);
         }
         const encrypted = columnReflectionData?.encrypted == true;
         const unwrappedSchemaIsUint8Array = isInstanceOf(unwrapSchema(schema).schema, Uint8ArraySchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.198",
+  "version": "0.93.200",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -153,8 +153,8 @@
     "type-fest": "^5.5"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.1025",
-    "@aws-sdk/s3-request-presigner": "^3.1025",
+    "@aws-sdk/client-s3": "3",
+    "@aws-sdk/s3-request-presigner": "3",
     "@genkit-ai/google-genai": "^1.31",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",

package/reflection/registry.d.ts

@@ -19,7 +19,7 @@ export type TypeMetadata = MetadataBase<'type'> & {
 };
 export type PropertyMetadata = MetadataBase<'property'> & {
     key: string | symbol;
-    type: AbstractConstructor;
+    type: AbstractConstructor | undefined;
     isAccessor: boolean;
     data: ContextDataMap;
     inherited: boolean;
@@ -36,7 +36,7 @@ export type ConstructorParameterMetadata = MetadataBase<'constructor-parameter'>
     data: ContextDataMap;
 };
 export type MethodParameterMetadata = MetadataBase<'method-parameter'> & {
-    type: AbstractConstructor;
+    type: AbstractConstructor | undefined;
     index: number;
     data: ContextDataMap;
 };

package/reflection/utils.js

@@ -85,20 +85,20 @@ export function getTypeInfoString(type) {
     lines.push(`${type.name}(${constructorParameters})`);
     for (const [key, propertyMetadata] of (metadata?.staticProperties ?? [])) {
         const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        lines.push(`  static ${propertyKey}: ${propertyMetadata.type.name}`);
+        lines.push(`  static ${propertyKey}: ${propertyMetadata.type?.name ?? '<unknown>'}`);
     }
     for (const [key, methodMetadata] of (metadata?.staticMethods ?? [])) {
         const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(', ');
+        const parameters = methodMetadata.parameters.map((parameter) => parameter.type?.name ?? '<unknown>').join(', ');
         lines.push(`  static ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? 'void'}`);
     }
     for (const [key, propertyMetadata] of (metadata?.properties ?? [])) {
         const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        lines.push(`  ${propertyKey}: ${propertyMetadata.type.name}`);
+        lines.push(`  ${propertyKey}: ${propertyMetadata.type?.name ?? '<unknown>'}`);
     }
     for (const [key, methodMetadata] of (metadata?.methods ?? [])) {
         const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(', ');
+        const parameters = methodMetadata.parameters.map((parameter) => parameter.type?.name ?? '<unknown>').join(', ');
         lines.push(`  ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? 'void'}`);
     }
     return lines.join('\n');

package/schema/schemas/function.js

@@ -56,7 +56,7 @@ export function tryGetFunctionSchemaFromReflection(type, method) {
     }
     const parameterSchemas = methodMetadata.parameters.map((parameterMetadata) => {
         const parameterData = parameterMetadata.data.tryGet('schema') ?? {};
-        return schemaReflectionDataToSchema(parameterData, parameterMetadata.type, { type, key: `${String(method)}(parameter:${parameterMetadata.index})` });
+        return schemaReflectionDataToSchema(parameterData, parameterMetadata.type ?? null, { type, key: `${String(method)}(parameter:${parameterMetadata.index})` });
     });
     const parameterNames = methodMetadata.parameters.map((parameterMetadata) => {
         const parameterData = parameterMetadata.data.tryGet('schema') ?? {};

package/schema/schemas/object.js

@@ -219,7 +219,7 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     const properties = {};
     for (const [key, propertyMetadata] of metadata.properties) {
         const reflectionData = propertyMetadata.data.tryGet('schema');
-        const propertySchema = schemaReflectionDataToSchema(reflectionData, propertyMetadata.type, { type, key });
+        const propertySchema = schemaReflectionDataToSchema(reflectionData, propertyMetadata.type ?? null, { type, key });
         properties[key] = propertySchema;
     }
     for (const [key] of metadata.methods) {

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

@@ -77,12 +77,15 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
         transaction?: Transaction;
     }): Promise<TaskOfType<Definitions, Type>[]>;
     reschedule(id: string, timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     rescheduleMany(ids: string[], timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     touch<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>, options?: {

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

@@ -187,6 +187,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 },
             }));
             const itemsWithIdempotency = entitiesWithIndex.filter((e) => isNotNull(e.entity.idempotencyKey));
+            itemsWithIdempotency.sort((a, b) => a.entity.idempotencyKey.localeCompare(b.entity.idempotencyKey));
             const itemsWithoutIdempotency = entitiesWithIndex.filter((e) => isNull(e.entity.idempotencyKey));
             const hasDependencies = itemsWithDistinctDependencies.some((item) => ((item.scheduleAfter?.length ?? 0) > 0) || ((item.completeAfter?.length ?? 0) > 0) || (isDefined(item.parentId) && (item.parentRequires != false) && !(isArray(item.parentRequires) && (item.parentRequires.length == 0))));
             const mustUseTransaction = (entitiesWithIndex.length > 1) || hasDependencies;
@@ -382,7 +383,6 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             decrementsToApply.set(dep.taskId, current);
         }
         const values = [...decrementsToApply]
-            .toSorted(([idA], [idB]) => idA.localeCompare(idB))
             .map(([taskId, d]) => sql `(${taskId}::uuid, ${d.schedule}::int, ${d.complete}::int)`);
         const updates = session.$with('updates').as((qb) => qb
             .select({
@@ -391,8 +391,14 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             completeIncrement: sql `(complete)::int`.as('complete_increment'),
         })
             .from(sql `(VALUES ${sql.join(values, sql `, `)}) AS t(id, schedule, complete)`));
+        const locked = session.$with('locked').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .innerJoin(updates, eq(taskTable.id, updates.taskId))
+            .orderBy(asc(taskTable.id))
+            .for('update'));
         const updatedRows = await session
-            .with(updates)
+            .with(updates, locked)
             .update(taskTable)
             .set({
             unresolvedScheduleDependencies: sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`,
@@ -400,7 +406,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             status: caseWhen(and(eq(taskTable.status, TaskStatus.Pending), gt(sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`, 0)), TaskStatus.Waiting).else(taskTable.status),
         })
             .from(updates)
-            .where(eq(taskTable.id, updates.taskId))
+            .where(and(eq(taskTable.id, updates.taskId), inArray(taskTable.id, session.select({ id: locked.id }).from(locked))))
             .returning({ id: taskTable.id, status: taskTable.status, namespace: taskTable.namespace });
         const notifiedNamespaces = new Set();
         for (const row of updatedRows) {
@@ -685,7 +691,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     }
     async rescheduleMany(ids, timestamp, options) {
         const session = options?.transaction?.pgTransaction ?? this.#repository.session;
-        await session
+        const result = await session
             .update(taskTable)
             .set({
             status: caseWhen(gt(taskTable.unresolvedScheduleDependencies, 0), enumValue(taskStatus, TaskStatus.Waiting)).else(enumValue(taskStatus, TaskStatus.Pending)),
@@ -694,11 +700,20 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             visibilityDeadline: null,
             tries: caseWhen(eq(taskTable.status, enumValue(taskStatus, TaskStatus.Running)), greatest(0, sql `${taskTable.tries} - 1`)).else(taskTable.tries),
         })
-            .where(and(inArray(taskTable.id, ids), notInArray(taskTable.status, terminalStatuses)));
+            .where(and(inArray(taskTable.id, ids), notInArray(taskTable.status, terminalStatuses)))
+            .returning({ id: taskTable.id });
+        if ((result.length > 0) && (options?.refundRateLimit == true)) {
+            try {
+                await this.#rateLimiter.refund(this.#namespace, result.length);
+            }
+            catch (error) {
+                this.#logger.error(error);
+            }
+        }
     }
     async rescheduleManyByTags(tags, timestamp, options) {
         const session = options?.transaction?.pgTransaction ?? this.#repository.session;
-        await session
+        const result = await session
             .update(taskTable)
             .set({
             status: caseWhen(gt(taskTable.unresolvedScheduleDependencies, 0), enumValue(taskStatus, TaskStatus.Waiting)).else(enumValue(taskStatus, TaskStatus.Pending)),
@@ -707,7 +722,16 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             visibilityDeadline: null,
             tries: caseWhen(eq(taskTable.status, enumValue(taskStatus, TaskStatus.Running)), greatest(0, sql `${taskTable.tries} - 1`)).else(taskTable.tries),
         })
-            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags)), notInArray(taskTable.status, terminalStatuses)));
+            .where(and(eq(taskTable.namespace, this.#namespace), arrayOverlaps(taskTable.tags, toArray(tags)), notInArray(taskTable.status, terminalStatuses)))
+            .returning({ id: taskTable.id });
+        if ((result.length > 0) && (options?.refundRateLimit == true)) {
+            try {
+                await this.#rateLimiter.refund(this.#namespace, result.length);
+            }
+            catch (error) {
+                this.#logger.error(error);
+            }
+        }
     }
     async touch(task, options) {
         if (isNull(task.token)) {
@@ -755,6 +779,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             updateState: sql `(state)::jsonb`.as('update_state'),
         })
             .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, progress, state)`));
+        const locked = session.$with('locked').as((qb) => qb
+            .select({ id: taskTable.id })
+            .from(taskTable)
+            .innerJoin(updates, eq(taskTable.id, updates.updateId))
+            .orderBy(asc(taskTable.id))
+            .for('update'));
         const updated = session.$with('updated').as(() => session
             .update(taskTable)
             .set({
@@ -763,10 +793,10 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             state: coalesce(updates.updateState, taskTable.state),
         })
             .from(updates)
-            .where(and(eq(taskTable.id, updates.updateId), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`, eq(taskTable.status, TaskStatus.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
+            .where(and(eq(taskTable.id, updates.updateId), inArray(taskTable.id, session.select({ id: locked.id }).from(locked)), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`, eq(taskTable.status, TaskStatus.Running), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
             .returning({ id: taskTable.id }));
         const result = await session
-            .with(updates, updated)
+            .with(updates, locked, updated)
             .select({ id: updated.id })
             .from(updated);
         return result.map((r) => r.id);
@@ -810,6 +840,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 updateProgress: sql `(progress)::numeric`.as('update_progress'),
             })
                 .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, result, progress)`));
+            const locked = tx.pgTransaction.$with('locked').as((qb) => qb
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .innerJoin(updates, eq(taskTable.id, updates.updateId))
+                .orderBy(asc(taskTable.id))
+                .for('update'));
             const updated = tx.pgTransaction.$with('updated').as(() => tx.pgTransaction
                 .update(taskTable)
                 .set({
@@ -821,10 +857,10 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 visibilityDeadline: null,
             })
                 .from(updates)
-                .where(and(eq(taskTable.id, updates.updateId), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`))
+                .where(and(eq(taskTable.id, updates.updateId), inArray(taskTable.id, tx.pgTransaction.select({ id: locked.id }).from(locked)), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`))
                 .returning({ id: taskTable.id, status: taskTable.status }));
             const updatedRows = await tx.pgTransaction
-                .with(updates, updated)
+                .with(updates, locked, updated)
                 .select({ id: updated.id, status: updated.status })
                 .from(updated);
             if (updatedRows.length > 0) {
@@ -879,6 +915,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 updateComplete: sql `(complete_timestamp)`.as('update_complete'),
             })
                 .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, tries, status, error, schedule_timestamp, complete_timestamp)`));
+            const locked = tx.pgTransaction.$with('locked').as((qb) => qb
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .innerJoin(updates, eq(taskTable.id, updates.updateId))
+                .orderBy(asc(taskTable.id))
+                .for('update'));
             const updated = tx.pgTransaction.$with('updated').as(() => tx.pgTransaction
                 .update(taskTable)
                 .set({
@@ -890,10 +932,10 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 completeTimestamp: sql `${updates.updateComplete}`,
             })
                 .from(updates)
-                .where(and(eq(taskTable.id, updates.updateId), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`, eq(taskTable.tries, updates.updateTries)))
+                .where(and(eq(taskTable.id, updates.updateId), inArray(taskTable.id, tx.pgTransaction.select({ id: locked.id }).from(locked)), sql `${taskTable.token} IS NOT DISTINCT FROM ${updates.updateToken}`, eq(taskTable.tries, updates.updateTries)))
                 .returning({ id: taskTable.id, status: taskTable.status }));
             const result = await tx.pgTransaction
-                .with(updates, updated)
+                .with(updates, locked, updated)
                 .select({ id: updated.id, status: updated.status })
                 .from(updated);
             if (result.length > 0) {
@@ -916,7 +958,9 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         await this.resolveDependenciesMany([{ id, status, namespace: options?.namespace }], options);
     }
     async resolveDependenciesMany(tasks, options) {
-        const tasksToResolve = tasks.filter((t) => terminalStatuses.includes(t.status));
+        const tasksToResolve = tasks
+            .filter((t) => terminalStatuses.includes(t.status))
+            .toSorted((a, b) => a.id.localeCompare(b.id));
         if (tasksToResolve.length == 0) {
             return;
         }
@@ -1013,7 +1057,6 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             }
             if (decrementsToApply.size > 0) {
                 const decrementValues = [...decrementsToApply]
-                    .toSorted(([idA], [idB]) => idA.localeCompare(idB))
                     .map(([taskId, d]) => sql `(${taskId}::uuid, ${d.schedule}::int, ${d.complete}::int)`);
                 const updates = tx.pgTransaction.$with('updates').as((qb) => qb
                     .select({
@@ -1022,8 +1065,14 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     completeDecrement: sql `(complete)::int`.as('complete_decrement'),
                 })
                     .from(sql `(VALUES ${sql.join(decrementValues, sql `, `)}) AS t(id, schedule, complete)`));
+                const locked = tx.pgTransaction.$with('locked').as((qb) => qb
+                    .select({ id: taskTable.id })
+                    .from(taskTable)
+                    .innerJoin(updates, eq(taskTable.id, updates.taskId))
+                    .orderBy(asc(taskTable.id))
+                    .for('update'));
                 const updatedRows = await tx.pgTransaction
-                    .with(updates)
+                    .with(updates, locked)
                     .update(taskTable)
                     .set({
                     unresolvedScheduleDependencies: greatest(0, sql `${taskTable.unresolvedScheduleDependencies} - ${updates.scheduleDecrement}`),
@@ -1034,7 +1083,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     token: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), null).else(taskTable.token),
                 })
                     .from(updates)
-                    .where(eq(taskTable.id, updates.taskId))
+                    .where(and(eq(taskTable.id, updates.taskId), inArray(taskTable.id, tx.pgTransaction.select({ id: locked.id }).from(locked))))
                     .returning({
                     id: taskTable.id,
                     namespace: taskTable.namespace,

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

@@ -33,10 +33,12 @@ declare class TaskContextImplementation<Definitions extends TaskDefinitionMap, T
     spawnMany<OtherDefinitions extends TaskDefinitionMap, SpawnType extends TaskTypes<OtherDefinitions>>(queue: TaskQueue<OtherDefinitions>, items: EnqueueManyItem<OtherDefinitions, SpawnType>[]): Promise<TaskOfType<OtherDefinitions, SpawnType>[]>;
     /** Stop execution and reschedule the task for later without incrementing tries if possible */
     reschedule(timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     reschedule(rescheduleOptions: {
         delay: number;
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     fail(error: unknown, options?: {

package/task-queue/task-context.js

@@ -83,12 +83,12 @@ class TaskContextImplementation {
         const items = queueOrItems.map((item) => ({ ...item, parentId: this.#task.id }));
         return await this.#queue.enqueueMany(items, { returnTasks: true });
     }
-    async reschedule(timestampOrDelay) {
+    async reschedule(timestampOrDelay, maybeOptions) {
         const isTimestamp = isNumber(timestampOrDelay);
         const timestamp = isTimestamp ? timestampOrDelay : (currentTimestamp() + timestampOrDelay.delay);
-        const transaction = isTimestamp ? undefined : timestampOrDelay.transaction;
+        const options = isTimestamp ? maybeOptions : timestampOrDelay;
         this.#logger.debug(`Rescheduling task for ${new Date(timestamp).toISOString()}.`);
-        await this.#queue.reschedule(this.#task.id, timestamp, { transaction });
+        await this.#queue.reschedule(this.#task.id, timestamp, options);
         this.#signal.set();
     }
     async fail(error, options) {

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

@@ -31,13 +31,19 @@ export declare class TaskProcessResult<Result = unknown> {
     /**
      * Creates a result that reschedules the task to a specific timestamp.
      * @param timestamp The timestamp to reschedule to.
+     * @param options Optional refund flags.
      */
-    static RescheduleTo<R>(timestamp: number): TaskProcessResult<R>;
+    static RescheduleTo<R>(timestamp: number, options?: {
+        refundRateLimit?: boolean;
+    }): TaskProcessResult<R>;
     /**
      * Creates a result that reschedules the task by a specific number of milliseconds.
      * @param milliseconds The number of milliseconds to reschedule by.
+     * @param options Optional refund flags.
      */
-    static RescheduleBy<R>(milliseconds: number): TaskProcessResult<R>;
+    static RescheduleBy<R>(milliseconds: number, options?: {
+        refundRateLimit?: boolean;
+    }): TaskProcessResult<R>;
 }
 /**
  * Represents the status of a task in the queue.
@@ -521,27 +527,30 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
      * Reschedules a task to run at a specific time.
      * @param id The ID of the task.
      * @param timestamp The timestamp when the task should run.
-     * @param options Optional transaction.
+     * @param options Optional transaction and refund flags.
      */
     abstract reschedule(id: string, timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     /**
      * Reschedules multiple tasks to run at a specific time.
      * @param ids The IDs of the tasks.
      * @param timestamp The timestamp when the tasks should run.
-     * @param options Optional transaction.
+     * @param options Optional transaction and refund flags.
      */
     abstract rescheduleMany(ids: string[], timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     /**
      * Reschedules tasks with the given tags to run at a specific time.
      * @param tags One or more tags.
      * @param timestamp The timestamp when the tasks should run.
-     * @param options Optional transaction.
+     * @param options Optional transaction and refund flags.
      */
     abstract rescheduleManyByTags(tags: OneOrMany<string>, timestamp: number, options?: {
+        refundRateLimit?: boolean;
         transaction?: Transaction;
     }): Promise<void>;
     /**

package/task-queue/task-queue.js

@@ -87,17 +87,19 @@ export class TaskProcessResult {
     /**
      * Creates a result that reschedules the task to a specific timestamp.
      * @param timestamp The timestamp to reschedule to.
+     * @param options Optional refund flags.
      */
-    static RescheduleTo(timestamp) {
-        return new TaskProcessResult({ action: 'reschedule', timestamp });
+    static RescheduleTo(timestamp, options) {
+        return new TaskProcessResult({ action: 'reschedule', timestamp, ...options });
     }
     /**
      * Creates a result that reschedules the task by a specific number of milliseconds.
      * @param milliseconds The number of milliseconds to reschedule by.
+     * @param options Optional refund flags.
      */
-    static RescheduleBy(milliseconds) {
+    static RescheduleBy(milliseconds, options) {
         const timestamp = currentTimestamp() + milliseconds;
-        return this.RescheduleTo(timestamp);
+        return this.RescheduleTo(timestamp, options);
     }
 }
 /**
@@ -275,7 +277,7 @@ export class TaskQueue extends Transactional {
                                 break;
                             case 'reschedule':
                                 context.logger.verbose('Rescheduling task');
-                                await this.reschedule(task.id, result.payload.timestamp);
+                                await this.reschedule(task.id, result.payload.timestamp, { refundRateLimit: result.payload.refundRateLimit });
                                 break;
                             default:
                                 throw new Error('Unsupported task result action.');

package/task-queue/types.d.ts

@@ -31,6 +31,7 @@ export type TaskProcessResultPayload<Result> = {
 } | {
     action: 'reschedule';
     timestamp: number;
+    refundRateLimit?: boolean;
 };
 export interface ProcessWorker<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     /**

package/test2.js

@@ -1,16 +1,34 @@
-import { inject, Singleton } from './injector/index.js';
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 import { Application } from './application/application.js';
 import { provideModule } from './application/providers.js';
+import { defineEnum } from './enumeration/enumeration.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
-import { object, string } from './schema/index.js';
-const schema = object({
-    value: string({ lowercase: true })
+import { Enumeration } from './schema/index.js';
+import { getDesignType } from './utils/reflection.js';
+const Status = defineEnum('Status', {
+    Active: 'active',
+    Inactive: 'inactive',
+    Suspended: 'suspended',
 });
+class TestClass {
+    status;
+}
+__decorate([
+    Enumeration(Status),
+    __metadata("design:type", String)
+], TestClass.prototype, "status", void 0);
 function main() {
-    const value = schema.parse({ value: 'HELLO WORLD' });
-    console.log(value);
+    console.log(getDesignType(TestClass.prototype, 'status'));
 }
 Application.run('Test', [
     provideModule(main),
-    provideConsoleLogTransport(PrettyPrintLogFormatter)
+    provideConsoleLogTransport(PrettyPrintLogFormatter),
 ]);