@tstdl/base 0.92.85 → 0.92.87

package/ai/ai.service.d.ts

@@ -44,7 +44,7 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
     getFileById(id: string): FileContentPart;
     classify<T extends EnumerationType>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<ClassificationResult<T>>>;
-    getClassifyConents(parts: OneOrMany<ContentPart>): Content[];
+    getClassifyContents(parts: OneOrMany<ContentPart>): Content[];
     extractData<T>(parts: OneOrMany<ContentPart>, schema: SchemaTestable<T>, options?: GenerationOptions & Pick<GenerationRequest, 'model'>): Promise<SpecializedGenerationResult<T>>;
     getExtractDataConents(parts: OneOrMany<ContentPart>): Content[];
     analyzeContent<T extends EnumerationType>(parts: OneOrMany<ContentPart>, types: T, options?: GenerationOptions & {
@@ -54,8 +54,8 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     getAnalyzeContentConents(parts: OneOrMany<ContentPart>): Content[];
     callFunctions<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): Promise<SpecializedGenerationResult<SchemaFunctionDeclarationsResult<T>[]>>;
     callFunctionsStream<const T extends SchemaFunctionDeclarations>(options: CallFunctionsOptions<T>): SpecializedGenerationResultGenerator<SchemaFunctionDeclarationsResult<T>>;
-    generate(request: GenerationRequest): Promise<GenerationResult>;
-    generateStream(request: GenerationRequest): AsyncGenerator<GenerationResult>;
+    generate<S>(request: GenerationRequest<S>): Promise<GenerationResult<S>>;
+    generateStream<S>(request: GenerationRequest<S>): AsyncGenerator<GenerationResult<S>>;
     private _callFunctionsStream;
     private convertContents;
     private convertContent;
@@ -63,4 +63,4 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     private convertGoogleContent;
     private getModel;
 }
-export declare function mergeGenerationStreamItems(items: GenerationResult[]): GenerationResult;
+export declare function mergeGenerationStreamItems<S>(items: GenerationResult<S>[], schema?: SchemaTestable<S>): GenerationResult<S>;

package/ai/ai.service.js

@@ -13,13 +13,14 @@ import { getShutdownSignal } from '../process-shutdown.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
 import { LazyPromise } from '../promise/lazy-promise.js';
 import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
-import { array, enumeration, nullable, object, string } from '../schema/index.js';
+import { array, enumeration, nullable, object, Schema, string } from '../schema/index.js';
 import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
+import { lazyObject } from '../utils/object/lazy-property.js';
 import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
 import { cancelableTimeout } from '../utils/timing.js';
-import { assertDefinedPass, assertNotNullPass, isDefined, isError, isNotNull, isUndefined } from '../utils/type-guards.js';
+import { assertDefinedPass, assertNotNullPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
 import { millisecondsPerSecond } from '../utils/units.js';
 import { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
@@ -43,7 +44,7 @@ let AiService = class AiService {
     #genAI = (isDefined(this.#options.vertex)
         ? new VertexAI({ project: this.#options.vertex.project, location: this.#options.vertex.location, googleAuthOptions: { apiKey: this.#options.apiKey, keyFile: this.#options.keyFile } })
         : new GoogleGenerativeAI(assertDefinedPass(this.#options.apiKey, 'Api key not defined')));
-    defaultModel = this.#options.defaultModel ?? 'gemini-2.0-flash-exp';
+    defaultModel = this.#options.defaultModel ?? 'gemini-2.0-flash';
     createSession() {
         return new AiSession(this);
     }
@@ -72,14 +73,14 @@ let AiService = class AiService {
             },
             generationSchema,
             systemInstruction: 'You are a highly accurate document classification AI. Your task is to analyze the content of a given document and determine its type based on a predefined list of possible document types.',
-            contents: this.getClassifyConents(parts)
+            contents: this.getClassifyContents(parts)
         });
         return {
             result: JSON.parse(assertNotNullPass(generation.text, 'No text returned.')),
             raw: generation
         };
     }
-    getClassifyConents(parts) {
+    getClassifyContents(parts) {
         return [{
                 role: 'user',
                 parts: [
@@ -192,7 +193,7 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
     }
     async generate(request) {
         const items = await toArrayAsync(this.generateStream(request));
-        return mergeGenerationStreamItems(items);
+        return mergeGenerationStreamItems(items, request.generationSchema);
     }
     async *generateStream(request) {
         const googleFunctionDeclarations = isDefined(request.functions) ? await this.convertFunctions(request.functions) : undefined;
@@ -261,6 +262,9 @@ Always output the content and tags in ${options?.targetLanguage ?? 'the same lan
                         }
                         return text;
                     },
+                    get json() {
+                        throw new NotSupportedError('JSON not supported in streamed items. Use mergeGenerationStreamItems to combine all streamed items.');
+                    },
                     get functionCalls() {
                         if (isUndefined(functionCallParts)) {
                             functionCallParts = content.parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
@@ -390,26 +394,35 @@ AiService = __decorate([
     Singleton()
 ], AiService);
 export { AiService };
-export function mergeGenerationStreamItems(items) {
+export function mergeGenerationStreamItems(items, schema) {
     const parts = items.flatMap((item) => item.content.parts);
     let text;
     let functionCallParts;
-    return {
-        content: { role: 'model', parts },
-        get text() {
+    return lazyObject({
+        content: { value: { role: 'model', parts } },
+        text() {
             if (isUndefined(text)) {
                 const textParts = parts.filter((part) => hasOwnProperty(part, 'text')).map((part) => part.text);
                 text = (textParts.length > 0) ? textParts.join('') : null;
             }
             return text;
         },
-        get functionCalls() {
+        json() {
+            if (isUndefined(schema)) {
+                return undefined;
+            }
+            if (isNull(this.text)) {
+                throw new Error('No text to parse available.');
+            }
+            return Schema.parse(schema, JSON.parse(this.text));
+        },
+        functionCalls() {
             if (isUndefined(functionCallParts)) {
                 functionCallParts = parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);
             }
             return functionCallParts;
         },
-        finishReason: items.at(-1).finishReason,
-        usage: items.at(-1).usage
-    };
+        finishReason: { value: items.at(-1).finishReason },
+        usage: { value: items.at(-1).usage }
+    });
 }

package/ai/types.d.ts

@@ -52,7 +52,7 @@ export type Content = {
 };
 export type FunctionCallingMode = 'auto' | 'force' | 'none';
 export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
-export type AiModel = LiteralUnion<'gemini-2.0-flash-exp' | 'gemini-exp-1206' | 'gemini-2.0-flash-thinking-exp-1219', string>;
+export type AiModel = LiteralUnion<'gemini-2.0-flash' | 'gemini-2.0-flash-lite' | 'gemini-2.0-pro-exp-02-05' | 'gemini-2.0-flash-thinking-exp-01-21', string>;
 export type GenerationOptions = {
     maxOutputTokens?: number;
     temperature?: number;
@@ -60,13 +60,13 @@ export type GenerationOptions = {
     topK?: number;
     frequencyPenalty?: number;
 };
-export type GenerationRequest = {
+export type GenerationRequest<S = unknown> = {
     model?: AiModel;
     systemInstruction?: string;
     contents: Content | readonly Content[];
     functions?: SchemaFunctionDeclarations;
     functionCallingMode?: FunctionCallingMode;
-    generationSchema?: SchemaTestable;
+    generationSchema?: SchemaTestable<S>;
     generationOptions?: GenerationOptions;
 };
 export type GenerationUsage = {
@@ -75,9 +75,10 @@ export type GenerationUsage = {
     output: number;
     total: number;
 };
-export type GenerationResult = {
+export type GenerationResult<S = unknown> = {
     content: Content;
     text: string | null;
+    json: S;
     functionCalls: FunctionCall[];
     finishReason: FinishReason;
     usage: GenerationUsage;

package/api/server/gateway.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import 'urlpattern-polyfill'; // eslint-disable-line import/no-unassigned-import
+import 'urlpattern-polyfill';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { NotImplementedError } from '../../errors/not-implemented.error.js';

package/authentication/authentication.api.d.ts

@@ -84,8 +84,8 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                readonly token: string;
-                readonly newSecret: string;
+                token: string;
+                newSecret: string;
             }>;
             result: import("../schema/index.js").LiteralSchema<"ok">;
         };
@@ -93,7 +93,7 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                readonly secret: string;
+                secret: string;
             }>;
             result: typeof SecretCheckResult;
         };
@@ -179,8 +179,8 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                readonly token: string;
-                readonly newSecret: string;
+                token: string;
+                newSecret: string;
             }>;
             result: import("../schema/index.js").LiteralSchema<"ok">;
         };
@@ -188,7 +188,7 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                readonly secret: string;
+                secret: string;
             }>;
             result: typeof SecretCheckResult;
         };
@@ -272,8 +272,8 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            readonly token: string;
-            readonly newSecret: string;
+            token: string;
+            newSecret: string;
         }>;
         result: import("../schema/index.js").LiteralSchema<"ok">;
     };
@@ -281,7 +281,7 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            readonly secret: string;
+            secret: string;
         }>;
         result: typeof SecretCheckResult;
     };

package/authentication/models/schemas.d.ts

@@ -1,5 +1,5 @@
 import { AuthenticationCredentials } from './authentication-credentials.model.js';
 import { AuthenticationSession } from './authentication-session.model.js';
 export declare const authenticationSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"authentication">;
-export declare const authenticationCredentials: import("../../orm/server/types.js").PgTableFromType<"authentication", typeof AuthenticationCredentials>;
-export declare const authenticationSession: import("../../orm/server/types.js").PgTableFromType<"authentication", typeof AuthenticationSession>;
+export declare const authenticationCredentials: import("../../orm/server/types.js").PgTableFromType<typeof AuthenticationCredentials, "authentication">;
+export declare const authenticationSession: import("../../orm/server/types.js").PgTableFromType<typeof AuthenticationSession, "authentication">;

package/authentication/server/authentication-ancillary.service.d.ts

@@ -1,10 +1,12 @@
+import { type EnumType } from '../../enumeration/enumeration.js';
 import type { Record } from '../../types.js';
 import type { TokenPayload } from '../index.js';
 import type { InitSecretResetData } from '../models/init-secret-reset-data.model.js';
-export declare enum GetTokenPayloadContextAction {
-    GetToken = 0,
-    Refresh = 1
-}
+export declare const GetTokenPayloadContextAction: {
+    readonly GetToken: "get-token";
+    readonly Refresh: "refresh";
+};
+export type GetTokenPayloadContextAction = EnumType<typeof GetTokenPayloadContextAction>;
 export type GetTokenPayloadContext = {
     action: GetTokenPayloadContextAction;
 };

package/authentication/server/authentication-ancillary.service.js

@@ -1,7 +1,7 @@
-export var GetTokenPayloadContextAction;
-(function (GetTokenPayloadContextAction) {
-    GetTokenPayloadContextAction[GetTokenPayloadContextAction["GetToken"] = 0] = "GetToken";
-    GetTokenPayloadContextAction[GetTokenPayloadContextAction["Refresh"] = 1] = "Refresh";
-})(GetTokenPayloadContextAction || (GetTokenPayloadContextAction = {}));
+import { defineEnum } from '../../enumeration/enumeration.js';
+export const GetTokenPayloadContextAction = defineEnum('GetTokenPayloadContextAction', {
+    GetToken: 'get-token',
+    Refresh: 'refresh'
+});
 export class AuthenticationAncillaryService {
 }

package/cancellation/token.d.ts

@@ -81,7 +81,7 @@ export declare class CancellationSignal implements PromiseLike<void>, Subscribab
      * @param target receiver to connect
      */
     connect(target: CancellationToken, config?: ConnectConfig): void;
-    then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
+    then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | null): Promise<TResult>;
     subscribe(observer: Partial<Observer<void>>): Unsubscribable;
 }
 export declare class CancellationToken extends CancellationSignal {

package/context/context.d.ts

@@ -7,12 +7,4 @@ export declare function createContextProvider<Context, const Name extends string
     (required: true, debugFn: Function): Context;
     (required?: false, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}> & Record<`setCurrent${Name}Context`, (context: Context | null) => Context | null> & Record<`runIn${Name}Context`, <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT> & Record<`isIn${Name}Context`, {
-    (required: true, debugFn: Function): Context;
-    (required?: false, debugFn?: Function): Context | null;
-    (required: boolean, debugFn: Function): Context | null;
-}> & Record<`assertIn${Name}Context`, {
-    (required: true, debugFn: Function): Context;
-    (required?: false, debugFn?: Function): Context | null;
-    (required: boolean, debugFn: Function): Context | null;
-}>>;
+}> & Record<`setCurrent${Name}Context`, (context: Context | null) => Context | null> & Record<`runIn${Name}Context`, <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT> & Record<`isIn${Name}Context`, () => boolean> & Record<`assertIn${Name}Context`, (debugFnOrMessage: Function | string) => void>>;

package/context/context.js

@@ -1,4 +1,4 @@
-import { isNotNull } from '../utils/type-guards.js';
+import { isNotNull, isString } from '../utils/type-guards.js';
 /**
  * Creates a new context provider
  * @param name name of of the context used for function names
@@ -48,16 +48,19 @@ export function createContextProvider(name) {
      *
      * @param debugFn a reference to the function making the assertion (used for the error message).
      */
-    function assertInContext(debugFn) {
+    function assertInContext(debugFnOrMessage) {
         if (!isInContext()) {
-            throw new Error(`${debugFn.name}() can only be used within an ${name}Context via \`runIn${name}Context\`.`);
+            const message = isString(debugFnOrMessage)
+                ? debugFnOrMessage
+                : `${debugFnOrMessage.name}() can only be used within an ${name}Context via \`runIn${name}Context\`.`;
+            throw new Error(message);
         }
     }
     return {
         [`getCurrent${name}Context`]: getCurrentContext,
         [`setCurrent${name}Context`]: setCurrentContext,
         [`runIn${name}Context`]: runInContext,
-        [`isIn${name}Context`]: getCurrentContext,
-        [`assertIn${name}Context`]: getCurrentContext
+        [`isIn${name}Context`]: isInContext,
+        [`assertIn${name}Context`]: assertInContext
     };
 }