typia/lib/transformers/features/llm/LlmSchemaTransformer.mjs

Superfast runtime validators with only one line

import ts from 'typescript';
import { IdentifierFactory } from '../../../factories/IdentifierFactory.mjs';
import { LiteralFactory } from '../../../factories/LiteralFactory.mjs';
import { MetadataCollection } from '../../../factories/MetadataCollection.mjs';
import { MetadataFactory } from '../../../factories/MetadataFactory.mjs';
import { LlmModelPredicator } from '../../../programmers/llm/LlmModelPredicator.mjs';
import { LlmSchemaProgrammer } from '../../../programmers/llm/LlmSchemaProgrammer.mjs';
import { TransformerError } from '../../TransformerError.mjs';

var LlmSchemaTransformer;
(function (LlmSchemaTransformer) {
    LlmSchemaTransformer.transform = (props) => {
        // GET GENERIC ARGUMENT
        if (!props.expression.typeArguments?.length)
            throw new TransformerError({
                code: "typia.llm.schema",
                message: "no generic argument.",
            });
        const top = props.expression.typeArguments[0];
        if (ts.isTypeNode(top) === false)
            return props.expression;
        // GET TYPE
        const model = LlmModelPredicator.getModel({
            checker: props.context.checker,
            method: "schema",
            node: props.expression.typeArguments[1],
        });
        const config = LlmModelPredicator.getConfig({
            context: props.context,
            method: "schema",
            model,
            node: props.expression.typeArguments[2],
        });
        const type = props.context.checker.getTypeFromTypeNode(top);
        // VALIDATE TYPE
        const analyze = (validate) => {
            const result = MetadataFactory.analyze({
                checker: props.context.checker,
                transformer: props.context.transformer,
                options: {
                    absorb: validate,
                    constant: true,
                    escape: true,
                    validate: validate === true
                        ? LlmSchemaProgrammer.validate({
                            model,
                            config,
                        })
                        : undefined,
                },
                collection: new MetadataCollection({
                    replace: MetadataCollection.replace,
                }),
                type,
            });
            if (result.success === false)
                throw TransformerError.from({
                    code: "typia.llm.schema",
                    errors: result.errors,
                });
            return result.data;
        };
        analyze(true);
        // GENERATE LLM SCHEMA
        const out = LlmSchemaProgrammer.write({
            model,
            metadata: analyze(false),
            config,
        });
        const schemaTypeNode = props.context.importer.type({
            file: "@samchon/openapi",
            name: "ILlmSchema",
            arguments: [
                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(model)),
            ],
        });
        const literal = ts.factory.createAsExpression(LiteralFactory.write(out.schema), schemaTypeNode);
        if (Object.keys(out.$defs).length === 0)
            return literal;
        return ts.factory.createCallExpression(ts.factory.createArrowFunction(undefined, undefined, [
            IdentifierFactory.parameter("props", ts.factory.createTypeLiteralNode([
                ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier("$defs"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createUnionTypeNode([
                    ts.factory.createTypeReferenceNode("Record", [
                        ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                        schemaTypeNode,
                    ]),
                    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
                ])),
            ]), undefined),
        ], undefined, undefined, ts.factory.createBlock([
            ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createIdentifier("undefined"), IdentifierFactory.access(ts.factory.createIdentifier("props"), "$defs", true)), ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("Object.assign"), undefined, [
                IdentifierFactory.access(ts.factory.createIdentifier("props"), "$defs"),
                ts.factory.createAsExpression(LiteralFactory.write(out.$defs), ts.factory.createTypeReferenceNode("Record", [
                    ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                    schemaTypeNode,
                ])),
            ]))),
            ts.factory.createReturnStatement(literal),
        ], true)), undefined, [props.expression.arguments[0]]);
    };
})(LlmSchemaTransformer || (LlmSchemaTransformer = {}));

export { LlmSchemaTransformer };
//# sourceMappingURL=LlmSchemaTransformer.mjs.map