@tstdl/base 0.93.125 → 0.93.126

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.125",
+  "version": "0.93.126",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -76,7 +76,6 @@
     "./jsx": "./jsx/index.js",
     "./key-value-store": "./key-value-store/index.js",
     "./key-value-store/postgres": "./key-value-store/postgres/index.js",
-    "./latex": "./latex/index.js",
     "./lock": "./lock/index.js",
     "./lock/postgres": "./lock/postgres/index.js",
     "./lock/web": "./lock/web/index.js",
@@ -93,8 +92,8 @@
     "./object-storage/s3": "./object-storage/s3/index.js",
     "./openid-connect": "./openid-connect/index.js",
     "./orm": "./orm/index.js",
-    "./orm/schemas": "./orm/schemas/index.js",
     "./orm/data-types": "./orm/data-types/index.js",
+    "./orm/schemas": "./orm/schemas/index.js",
     "./orm/server": "./orm/server/index.js",
     "./password": "./password/index.js",
     "./pdf": "./pdf/index.js",
@@ -105,6 +104,7 @@
     "./rate-limit": "./rate-limit/index.js",
     "./rate-limit/postgres": "./rate-limit/postgres/index.js",
     "./reflection": "./reflection/index.js",
+    "./renderer": "./renderer/index.js",
     "./rpc": "./rpc/index.js",
     "./rpc/endpoints": "./rpc/endpoints/index.js",
     "./rxjs-utils": "./rxjs-utils/index.js",
@@ -125,11 +125,10 @@
     "./templates/renderers": "./templates/renderers/index.js",
     "./templates/resolvers": "./templates/resolvers/index.js",
     "./templates/types": "./templates/types/index.js",
+    "./testing": "./testing/index.js",
     "./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",
     "./utils/async-hook": "./utils/async-hook/index.js",
@@ -153,7 +152,6 @@
   "peerDependencies": {
     "@genkit-ai/google-genai": "^1.28",
     "@google-cloud/storage": "^7.19",
-    "@google/genai": "^1.40",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
@@ -164,8 +162,8 @@
     "file-type": "^21.3",
     "genkit": "^1.28",
     "handlebars": "^4.7",
-    "@aws-sdk/client-s3": "^3.986",
-    "@aws-sdk/s3-request-presigner": "^3.986",
+    "@aws-sdk/client-s3": "^3.990",
+    "@aws-sdk/s3-request-presigner": "^3.990",
     "mjml": "^4.18",
     "nodemailer": "^8.0",
     "pg": "^8.18",
@@ -173,7 +171,7 @@
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.21",
+    "undici": "^7.22",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -1,26 +1,23 @@
-import { afterAll, describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { RateLimiterProvider } from '../../rate-limit/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('PostgresRateLimiter Integration Tests', () => {
     let injector;
     let rateLimiter;
     const limiterName = `test-limiter-${Date.now()}`;
-    async function getLimiter() {
-        if (injector == null) {
-            ({ injector } = await setupIntegrationTest({ modules: { rateLimiter: true } }));
-        }
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { rateLimiter: true } }));
         const rateLimiterProvider = injector.resolve(RateLimiterProvider);
-        return rateLimiterProvider.get(limiterName, {
+        rateLimiter = rateLimiterProvider.get(limiterName, {
             burstCapacity: 10,
             refillInterval: 1000, // 10 tokens per second -> 1 token per 100ms
         });
-    }
+    });
     afterAll(async () => {
         await injector?.dispose();
     }, 15000);
     it('should acquire tokens successfully', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-1';
         const result = await rateLimiter.tryAcquire(resource, 5);
         expect(result).toBe(true);
@@ -30,7 +27,6 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(result3).toBe(false);
     });
     it('should refill tokens over time', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-2';
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
@@ -40,7 +36,6 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should refund tokens', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-3';
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
@@ -49,14 +44,12 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should handle fractional tokens', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-4';
         await rateLimiter.tryAcquire(resource, 9.5);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
         expect(await rateLimiter.tryAcquire(resource, 0.5)).toBe(true);
     });
     it('should handle concurrent acquisitions', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-concurrent';
         // Initialize
         await rateLimiter.tryAcquire(resource, 0);
@@ -65,19 +58,16 @@ describe('PostgresRateLimiter Integration Tests', () => {
         expect(successCount).toBe(10);
     }, 15000);
     it('should always allow zero or negative cost', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-zero';
         expect(await rateLimiter.tryAcquire(resource, 0)).toBe(true);
         expect(await rateLimiter.tryAcquire(resource, -1)).toBe(true);
     });
     it('should reject cost greater than burst capacity', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-large';
         // Burst capacity is 10
         expect(await rateLimiter.tryAcquire(resource, 11)).toBe(false);
     });
     it('should cap tokens at burst capacity on refill', async () => {
-        rateLimiter = await getLimiter();
         const resource = 'res-refill-cap';
         // Drain
         await rateLimiter.tryAcquire(resource, 10);

package/renderer/d2.d.ts

@@ -0,0 +1,77 @@
+export type D2RenderOptions = {
+    /**
+     * The layout engine to use.
+     * @default 'dagre'
+     */
+    layout?: string;
+    /**
+     * The theme ID to use.
+     * @default 0
+     */
+    theme?: number;
+    /**
+     * The dark theme ID to use.
+     */
+    darkTheme?: number;
+    /**
+     * Pixels padded around the rendered diagram.
+     * @default 100
+     */
+    pad?: number;
+    /**
+     * Render the diagram to look like it was sketched by hand.
+     * @default false
+     */
+    sketch?: boolean;
+    /**
+     * Center the SVG in the containing viewbox.
+     * @default false
+     */
+    center?: boolean;
+    /**
+     * if given, multiple boards are packaged as 1 SVG which transitions through each board at the interval (in milliseconds).
+     * Can only be used with SVG exports.
+     * @default 0
+     */
+    animateInterval?: number;
+    /**
+     * Omit XML tag (<?xml ...?>) from output SVG files.
+     * @default false
+     */
+    noXmlTag?: boolean;
+    /**
+     * Add a salt value to ensure the output uses unique IDs.
+     */
+    salt?: string;
+    /**
+     * Omit D2 version from generated image.
+     * @default false
+     */
+    omitVersion?: boolean;
+    /**
+     * Target board to render.
+     * @default '*'
+     */
+    target?: string;
+    /**
+     * Scale the output. E.g., 0.5 to halve the default size.
+     * @default -1
+     */
+    scale?: number;
+    /**
+     * The output format for the rendered diagram.
+     * @default 'svg'
+     */
+    format?: 'svg' | 'png' | 'ascii' | 'txt' | 'pdf' | 'pptx' | 'gif';
+};
+/**
+ * Renders D2 source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted D2 source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires d2 to be installed on the system.
+ * @param source The D2 source code to render
+ * @param options Rendering options
+ */
+export declare function renderD2(source: string, options?: D2RenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/renderer/d2.js

@@ -0,0 +1,68 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+import { isDefined } from '../utils/type-guards.js';
+/**
+ * Renders D2 source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted D2 source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires d2 to be installed on the system.
+ * @param source The D2 source code to render
+ * @param options Rendering options
+ */
+export async function renderD2(source, options) {
+    const format = options?.format ?? 'svg';
+    const args = ['-', '-', '--stdout-format', format];
+    if (isDefined(options?.layout)) {
+        args.push('--layout', options.layout);
+    }
+    if (isDefined(options?.theme)) {
+        args.push('--theme', options.theme.toString());
+    }
+    if (isDefined(options?.darkTheme)) {
+        args.push('--dark-theme', options.darkTheme.toString());
+    }
+    if (isDefined(options?.pad)) {
+        args.push('--pad', options.pad.toString());
+    }
+    if (options?.sketch == true) {
+        args.push('--sketch');
+    }
+    if (options?.center == true) {
+        args.push('--center');
+    }
+    if (isDefined(options?.animateInterval)) {
+        args.push('--animate-interval', options.animateInterval.toString());
+    }
+    if (options?.noXmlTag == true) {
+        args.push('--no-xml-tag');
+    }
+    if (isDefined(options?.salt)) {
+        args.push('--salt', options.salt);
+    }
+    if (options?.omitVersion == true) {
+        args.push('--omit-version');
+    }
+    if (isDefined(options?.target)) {
+        args.push('--target', options.target);
+    }
+    if (isDefined(options?.scale)) {
+        args.push('--scale', options.scale.toString());
+    }
+    const process = await spawnCommand('d2', 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(`
+D2 rendering failed with exit code ${code}.
+
+Error Output:
+${errorString}
+`.trim());
+    }
+    return output;
+}

package/renderer/graphviz.d.ts

@@ -0,0 +1,47 @@
+export type GraphvizRenderOptions = {
+    /**
+     * The layout engine to use.
+     * @default 'dot'
+     */
+    engine?: 'dot' | 'neato' | 'fdp' | 'sfdp' | 'twopi' | 'circo';
+    /**
+     * The output format for the rendered diagram.
+     * @default 'svg'
+     */
+    format?: 'svg' | 'png' | 'pdf' | 'jpg' | 'gif' | 'bmp' | 'eps' | 'ps' | 'tiff' | 'webp' | 'canon' | 'dot' | 'xdot' | 'plain' | 'plain-ext';
+    /**
+     * Set graph attributes (equivalent to -Gname=val)
+     */
+    graphAttributes?: Record<string, string>;
+    /**
+     * Set node attributes (equivalent to -Nname=val)
+     */
+    nodeAttributes?: Record<string, string>;
+    /**
+     * Set edge attributes (equivalent to -Ename=val)
+     */
+    edgeAttributes?: Record<string, string>;
+    /**
+     * Scale input by 'scale' (equivalent to -s[scale])
+     */
+    scale?: number;
+    /**
+     * Invert y coordinate in output (equivalent to -y)
+     */
+    invertY?: boolean;
+    /**
+     * Set level of message suppression (equivalent to -q[quiet])
+     */
+    quiet?: boolean | number;
+};
+/**
+ * Renders Graphviz (DOT) source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted Graphviz source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires Graphviz to be installed on the system.
+ * @param source The Graphviz source code to render
+ * @param options Rendering options
+ */
+export declare function renderGraphviz(source: string, options?: GraphvizRenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/renderer/graphviz.js

@@ -0,0 +1,58 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+import { isDefined } from '../utils/type-guards.js';
+/**
+ * Renders Graphviz (DOT) source code to a file in the specified format.
+ *
+ * ## WARNING
+ * **This function should not be used with untrusted Graphviz source, as it can lead to arbitrary code execution on the system.**
+ *
+ * Requires Graphviz to be installed on the system.
+ * @param source The Graphviz source code to render
+ * @param options Rendering options
+ */
+export async function renderGraphviz(source, options) {
+    const engine = options?.engine ?? 'dot';
+    const format = options?.format ?? 'svg';
+    const args = [`-T${format}`];
+    if (isDefined(options?.graphAttributes)) {
+        for (const [name, val] of Object.entries(options.graphAttributes)) {
+            args.push(`-G${name}=${val}`);
+        }
+    }
+    if (isDefined(options?.nodeAttributes)) {
+        for (const [name, val] of Object.entries(options.nodeAttributes)) {
+            args.push(`-N${name}=${val}`);
+        }
+    }
+    if (isDefined(options?.edgeAttributes)) {
+        for (const [name, val] of Object.entries(options.edgeAttributes)) {
+            args.push(`-E${name}=${val}`);
+        }
+    }
+    if (isDefined(options?.scale)) {
+        args.push(`-s${options.scale}`);
+    }
+    if (options?.invertY == true) {
+        args.push('-y');
+    }
+    if (isDefined(options?.quiet)) {
+        const level = (options.quiet == true) ? '' : options.quiet.toString();
+        args.push(`-q${level}`);
+    }
+    const process = await spawnCommand(engine, 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(`
+Graphviz rendering failed with exit code ${code}.
+
+Error Output:
+${errorString}
+`.trim());
+    }
+    return output;
+}

package/renderer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './d2.js';
+export * from './graphviz.js';
+export * from './latex.js';
+export * from './typst.js';

package/renderer/index.js

@@ -0,0 +1,4 @@
+export * from './d2.js';
+export * from './graphviz.js';
+export * from './latex.js';
+export * from './typst.js';

package/renderer/typst.d.ts

@@ -0,0 +1,57 @@
+import type { LiteralUnion } from 'type-fest';
+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';
+    /**
+     * Which pages to render.
+     */
+    pages?: (string | number | {
+        from?: number;
+        to?: number;
+    })[];
+    /**
+     * Add string key-value pairs visible through `sys.inputs`
+     */
+    inputs?: Record<string, string>;
+    /**
+     * The document's creation date formatted as a UNIX timestamp in milliseconds.
+     */
+    creationTimestamp?: number;
+    /**
+     * Adds additional directories that are recursively searched for fonts.
+     */
+    fontPaths?: string[];
+    /**
+     * Ensures system fonts won't be searched, unless explicitly included via `fontPaths`.
+     * @default false
+     */
+    ignoreSystemFonts?: boolean;
+    /**
+     * The PPI (pixels per inch) to use for PNG export.
+     * @default 144
+     */
+    ppi?: number;
+    /**
+     * One (or multiple comma-separated) PDF standards that Typst will enforce conformance with.
+     */
+    pdfStandard?: LiteralUnion<'1.4' | '1.5' | '1.6' | '1.7' | '2.0' | 'a-1b' | 'a-1a' | 'a-2b' | 'a-2u' | 'a-2a' | 'a-3b' | 'a-3u' | 'a-3a' | 'a-4' | 'a-4f' | 'a-4e' | 'ua-1', string>;
+};
+/**
+ * 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<ArrayBuffer>>;

package/renderer/typst.js

@@ -0,0 +1,62 @@
+import { spawnCommand } from '../process/spawn.js';
+import { decodeText } from '../utils/encoding.js';
+import { isDefined, isNumber, isString } from '../utils/type-guards.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';
+    let args = (format == 'docx')
+        ? ['--from', 'typst', '--to', 'docx', '--output']
+        : ['compile', '--format', format];
+    if (command == 'typst') {
+        if (isDefined(options?.root)) {
+            args.push('--root', options.root);
+        }
+        if (isDefined(options?.creationTimestamp)) {
+            args.push('--creation-timestamp', Math.floor(options.creationTimestamp / 1000).toString());
+        }
+        if (isDefined(options?.fontPaths)) {
+            for (const fontPath of options.fontPaths) {
+                args.push('--font-path', fontPath);
+            }
+        }
+        if (options?.ignoreSystemFonts == true) {
+            args.push('--ignore-system-fonts');
+        }
+        if (isDefined(options?.ppi)) {
+            args.push('--ppi', options.ppi.toString());
+        }
+        if (isDefined(options?.pdfStandard)) {
+            args.push('--pdf-standard', options.pdfStandard);
+        }
+        if (isDefined(options?.pages)) {
+            const pageParts = options.pages.map((page) => (isNumber(page) || isString(page))
+                ? page.toString()
+                : `${page.from ?? ''}-${page.to ?? ''}`);
+            args.push('--pages', pageParts.join(','));
+        }
+    }
+    args.push('-', '-');
+    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;
+}

package/rpc/adapters/readable-stream.adapter.d.ts

@@ -13,6 +13,9 @@ type Response<T> = {
     type: 'done';
 } | {
     type: 'void';
+} | {
+    type: 'throw';
+    error: Error;
 };
 export declare class ReadableStreamRpcAdapter<T> implements RpcAdapter<ReadableStream<T>, void, void, Request, Response<T>> {
     readonly name = "ReadableStream";

package/rpc/adapters/readable-stream.adapter.js

@@ -57,6 +57,10 @@ export class ReadableStreamRpcAdapter {
                         controller.close();
                         break;
                     }
+                    case 'throw': {
+                        controller.error(response.error);
+                        break;
+                    }
                     default: {
                         throw new NotSupportedError(`Type ${response.type} is not supported.`);
                     }
@@ -65,7 +69,7 @@ export class ReadableStreamRpcAdapter {
             async cancel(reason) {
                 await channel.request({ type: 'cancel', reason });
                 channel.close();
-            }
+            },
         });
     }
 }

package/rpc/rpc.js

@@ -19,6 +19,9 @@ const proxyTargets = new WeakSet();
 const exposings = new Map();
 const proxyChannels = new WeakMap();
 const channelFinalizationRegistry = new FinalizationRegistry((data) => data.channel.close());
+const rpcSet = Symbol('Rpc.set');
+const rpcDelete = Symbol('Rpc.delete');
+const rpcHas = Symbol('Rpc.has');
 class RpcProxy {
 }
 export const Rpc = {
@@ -107,13 +110,13 @@ export const Rpc = {
         return isDefined(channel);
     },
     async set(proxy, property, value) {
-        await Reflect.set(proxy, property, value);
+        await proxy[rpcSet](property, value);
     },
     async delete(proxy, property) {
-        return await Reflect.deleteProperty(proxy, property);
+        return await proxy[rpcDelete](property);
     },
     async has(proxy, property) {
-        return await Reflect.has(proxy, property);
+        return await proxy[rpcHas](property);
     },
     reset() {
         exposings.clear();
@@ -141,6 +144,28 @@ function createProxy(channel, path = []) {
                 .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
         },
         get(_target, property) {
+            if (property == rpcSet) {
+                return async (prop, value) => {
+                    const postMessageData = getPostMessageData(value, endpoint);
+                    return await channel
+                        .request({ type: 'set', path: [...path, prop], value: postMessageData.value }, postMessageData.transfer)
+                        .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                };
+            }
+            if (property == rpcDelete) {
+                return async (prop) => {
+                    return await channel
+                        .request({ type: 'deleteProperty', path: [...path, prop] })
+                        .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                };
+            }
+            if (property == rpcHas) {
+                return async (prop) => {
+                    return await channel
+                        .request({ type: 'has', path: [...path, prop] })
+                        .then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                };
+            }
             if (property == 'then') {
                 if (path.length == 0) {
                     return { then: () => proxy };

package/rpc/tests/rpc.integration.test.js

@@ -187,6 +187,8 @@ describe('Rpc Integration', () => {
         const proxy = await Rpc.connect(clientEndpoint, 'test-service-helpers');
         expect(await Rpc.has(proxy, 'foo')).toBe(true);
         expect(await Rpc.has(proxy, 'nonExistent')).toBe(false);
+        // Standard Reflect.has on a proxy with async traps will always be true (truthy promise)
+        expect(Reflect.has(proxy, 'nonExistent')).toBe(true);
         const deleteResult = await Rpc.delete(proxy, 'foo');
         expect(deleteResult).toBe(true);
         expect(await Rpc.has(proxy, 'foo')).toBe(false);
@@ -522,7 +524,7 @@ describe('Rpc Integration', () => {
     });
     it('should throw when serializing a marked rpc proxy directly', async () => {
         const { serialize } = await import('../../serializer/index.js');
-        const proxyInstance = new Rpc._RpcProxy();
+        const proxyInstance = new Rpc[internal].RpcProxy();
         expect(() => serialize(proxyInstance)).toThrow(NotSupportedError);
     });
     it('should support serializing an object marked with Rpc.adapt', async () => {

package/schema/schemas/nullable.js

@@ -8,7 +8,7 @@ export class NullableSchema extends Schema {
     schema;
     constructor(schema) {
         if ((schema instanceof NullableSchema) && (schema == schema.schema)) {
-            return schema; // eslint-disable-line no-constructor-return
+            return schema;
         }
         super();
         this.schema = schemaTestableToSchema(schema);

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

@@ -1,5 +1,6 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import { type EnumType } from '../enumeration/enumeration.js';
+import { Injector } from '../injector/index.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import { Logger } from '../logger/logger.js';
 import type { Transaction } from '../orm/server/transaction.js';
@@ -179,6 +180,7 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
     namespace: string;
 }> implements Resolvable<TaskQueueArgument> {
     readonly [resolveArgumentType]: TaskQueueArgument;
+    protected readonly injector: Injector;
     protected readonly config: QueueConfig & {
         namespace: string;
     };