@tstdl/base 0.93.199 → 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.199",
+  "version": "0.93.200",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -153,8 +153,8 @@
     "type-fest": "^5.5"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.1026",
-    "@aws-sdk/s3-request-presigner": "^3.1026",
+    "@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

@@ -691,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)),
@@ -700,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)),
@@ -713,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)) {

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),
 ]);