typia 8.0.0 → 8.0.1

package/lib/programmers/json/JsonStringifyProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonStringifyProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/json/JsonValidateParseProgrammer.mjs

@@ -0,0 +1,74 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+
+var JsonValidateParseProgrammer;
+(function (JsonValidateParseProgrammer) {
+    JsonValidateParseProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+            },
+        });
+        return {
+            functions: validate.functions,
+            statements: [
+                ...validate.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("string"))], props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [
+                    props.context.importer.type({
+                        file: "typia",
+                        name: "Primitive",
+                        arguments: [
+                            ts.factory.createTypeReferenceNode(props.name ??
+                                TypeFactory.getFullName({
+                                    checker: props.context.checker,
+                                    type: props.type,
+                                })),
+                        ],
+                    }),
+                ],
+            }), undefined, ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("JSON.parse"), undefined, [ts.factory.createIdentifier("input")]),
+            ]), ts.factory.createTypeReferenceNode("any"))),
+        };
+    };
+    JsonValidateParseProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = JsonValidateParseProgrammer.decompose({
+            context: props.context,
+            modulo: props.modulo,
+            functor,
+            type: props.type,
+            name: props.name,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(JsonValidateParseProgrammer || (JsonValidateParseProgrammer = {}));
+
+export { JsonValidateParseProgrammer };
+//# sourceMappingURL=JsonValidateParseProgrammer.mjs.map

package/lib/programmers/json/JsonValidateParseProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonValidateParseProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/json/JsonValidateStringifyProgrammer.mjs

@@ -0,0 +1,83 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { JsonStringifyProgrammer } from './JsonStringifyProgrammer.mjs';
+
+var JsonValidateStringifyProgrammer;
+(function (JsonValidateStringifyProgrammer) {
+    JsonValidateStringifyProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: true,
+                },
+            },
+            config: {
+                equals: false,
+            },
+        });
+        const stringify = JsonStringifyProgrammer.decompose({
+            ...props,
+            validated: true,
+        });
+        return {
+            functions: {
+                ...validate.functions,
+                ...stringify.functions,
+            },
+            statements: [
+                ...validate.statements,
+                ...stringify.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__stringify",
+                    value: stringify.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))], props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [
+                    stringify.arrow.type ??
+                        ts.factory.createTypeReferenceNode("string"),
+                ],
+            }), undefined, ts.factory.createBlock([
+                StatementFactory.constant({
+                    name: "result",
+                    value: ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [ts.factory.createIdentifier("input")]), TypeFactory.keyword("any")),
+                }),
+                ts.factory.createIfStatement(ts.factory.createIdentifier("result.success"), ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier("result.data"), ts.SyntaxKind.EqualsToken, ts.factory.createCallExpression(ts.factory.createIdentifier("__stringify"), undefined, [ts.factory.createIdentifier("input")])))),
+                ts.factory.createReturnStatement(ts.factory.createIdentifier("result")),
+            ])),
+        };
+    };
+    JsonValidateStringifyProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = JsonValidateStringifyProgrammer.decompose({
+            context: props.context,
+            modulo: props.modulo,
+            functor,
+            type: props.type,
+            name: props.name,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(JsonValidateStringifyProgrammer || (JsonValidateStringifyProgrammer = {}));
+
+export { JsonValidateStringifyProgrammer };
+//# sourceMappingURL=JsonValidateStringifyProgrammer.mjs.map

package/lib/programmers/json/JsonValidateStringifyProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonValidateStringifyProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/llm/LlmApplicationProgrammer.mjs

@@ -0,0 +1,270 @@
+import { LlmSchemaComposer } from '@samchon/openapi/lib/composers/LlmSchemaComposer.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { JsonApplicationProgrammer } from '../json/JsonApplicationProgrammer.mjs';
+import { LlmSchemaProgrammer } from './LlmSchemaProgrammer.mjs';
+
+var LlmApplicationProgrammer;
+(function (LlmApplicationProgrammer) {
+    LlmApplicationProgrammer.validate = (props) => {
+        let top;
+        return (metadata, explore) => {
+            top ??= metadata;
+            if (explore.top === false)
+                if (explore.object === top?.objects[0]?.type &&
+                    typeof explore.property === "string" &&
+                    metadata.size() === 1 &&
+                    metadata.nullable === false &&
+                    metadata.isRequired() === true &&
+                    metadata.functions.length === 1)
+                    return validateFunction(explore.property, metadata.functions[0]);
+                else
+                    return LlmSchemaProgrammer.validate(props)(metadata);
+            const output = [];
+            const validity = metadata.size() === 1 &&
+                metadata.objects.length === 1 &&
+                metadata.isRequired() === true &&
+                metadata.nullable === false;
+            if (validity === false)
+                output.push("LLM application's generic argument must be a class/interface type.");
+            const object = metadata.objects[0]?.type;
+            if (object !== undefined) {
+                if (object.properties.some((p) => p.key.isSoleLiteral() === false))
+                    output.push("LLM application does not allow dynamic keys on class/interface type.");
+                let least = false;
+                for (const p of object.properties) {
+                    const name = JSON.stringify(p.key.getSoleLiteral());
+                    const value = p.value;
+                    if (value.functions.length) {
+                        least ||= true;
+                        if (validity === false) {
+                            if (value.functions.length !== 1 || value.size() !== 1)
+                                output.push(`LLM application's function (${name}) type does not allow union type.`);
+                            if (value.isRequired() === false)
+                                output.push(`LLM application's function (${name}) type must be required.`);
+                            if (value.nullable === true)
+                                output.push(`LLM application's function (${name}) type must not be nullable.`);
+                        }
+                        const description = concatDescription(JsonApplicationProgrammer.writeDescription({
+                            description: p.description ??
+                                p.jsDocTags.find((tag) => tag.name === "description")
+                                    ?.text?.[0]?.text ??
+                                null,
+                            jsDocTags: p.jsDocTags,
+                            kind: "summary",
+                        }));
+                        if (description !== undefined && description.length > 1_024)
+                            output.push(`LLM application's function (${name}) description must not exceed 1,024 characters.`);
+                    }
+                }
+                if (least === false)
+                    output.push("LLM application's target type must have at least a function type.");
+            }
+            return output;
+        };
+    };
+    const validateFunction = (name, func) => {
+        const output = [];
+        const prefix = `LLM application's function (${JSON.stringify(name)})`;
+        if (func.output.size() && func.output.isRequired() === false)
+            output.push(`${prefix}'s return type must not be union type with undefined.`);
+        if (/^[0-9]/.test(name[0] ?? "") === true)
+            output.push(`${prefix} name must not start with a number.`);
+        if (/^[a-zA-Z0-9_-]+$/.test(name) === false)
+            output.push(`${prefix} name must be alphanumeric with underscore or hyphen.`);
+        if (name.length > 64)
+            output.push(`${prefix} name must not exceed 64 characters.`);
+        if (func.parameters.length !== 0 && func.parameters.length !== 1)
+            output.push(`${prefix} must have a single parameter.`);
+        if (func.parameters.length !== 0) {
+            const type = func.parameters[0].type;
+            if (type.size() !== 1 || type.objects.length !== 1)
+                output.push(`${prefix}'s parameter must be an object type.`);
+            else {
+                if (type.objects[0].type.properties.some((p) => p.key.isSoleLiteral() === false))
+                    output.push(`${prefix}'s parameter must not have dynamic keys.`);
+                if (type.isRequired() === false)
+                    output.push(`${prefix}'s parameter must not be union type with undefined.`);
+                if (type.nullable === true)
+                    output.push(`${prefix}'s parameter must not be nullable.`);
+            }
+        }
+        return output;
+    };
+    LlmApplicationProgrammer.write = (props) => {
+        const errors = LlmApplicationProgrammer.validate(props)(props.metadata, {
+            top: true,
+            object: null,
+            property: null,
+            parameter: null,
+            nested: null,
+            aliased: false,
+            escaped: false,
+            output: false,
+        });
+        if (errors.length)
+            throw new Error("Failed to write LLM application: " + errors.join("\n"));
+        const functionParameters = Object.fromEntries(props.metadata.objects[0].type.properties.filter((p) => p.key.isSoleLiteral() &&
+            p.value.size() === 1 &&
+            p.value.nullable === false &&
+            p.value.isRequired() === true &&
+            p.value.functions.length === 1)
+            .filter((p) => p.jsDocTags.find((tag) => tag.name === "hidden" || tag.name === "internal") === undefined)
+            .map((p) => [
+            p.key.getSoleLiteral(),
+            p.value.functions[0].parameters[0],
+        ]));
+        const errorMessages = [];
+        const application = JsonApplicationProgrammer.write({
+            version: "3.1",
+            metadata: props.metadata,
+            filter: (p) => p.jsDocTags.some((tag) => tag.name === "human") === false,
+        });
+        const functions = application.functions.map((func) => writeFunction({
+            model: props.model,
+            context: props.context,
+            modulo: props.modulo,
+            className: props.name,
+            components: application.components,
+            function: func,
+            errors: errorMessages,
+            parameter: functionParameters[func.name] ?? null,
+        }));
+        if (functions.some((func) => func === null))
+            throw new Error("Failed to write LLM application:\n\n" +
+                errorMessages.map((str) => `  - ${str}`).join("\n"));
+        return {
+            model: props.model,
+            options: {
+                ...LlmSchemaComposer.defaultConfig(props.model),
+                ...props.config,
+                separate: null,
+            },
+            functions: functions,
+        };
+    };
+    const writeFunction = (props) => {
+        const parameters = writeParameters({
+            ...props,
+            accessor: `$input.${props.function.name}.parameters`,
+        });
+        if (parameters === null)
+            return null;
+        const output = writeOutput({
+            model: props.model,
+            parameters,
+            components: props.components,
+            schema: props.function.output?.schema ?? null,
+            errors: props.errors,
+            accessor: `$input.${props.function.name}.output`,
+        });
+        if (output === null)
+            return null;
+        else if (output &&
+            output.description === undefined &&
+            !!props.function.output?.description?.length)
+            output.description = props.function.output.description;
+        return {
+            name: props.function.name,
+            parameters,
+            output: (output ?? undefined),
+            description: (() => {
+                if (!props.function.summary?.length ||
+                    !props.function.description?.length)
+                    return props.function.summary || props.function.description;
+                const summary = props.function.summary.endsWith(".")
+                    ? props.function.summary.slice(0, -1)
+                    : props.function.summary;
+                return props.function.description.startsWith(summary)
+                    ? props.function.description
+                    : summary + ".\n\n" + props.function.description;
+            })(),
+            deprecated: props.function.deprecated,
+            tags: props.function.tags,
+            validate: writeValidadtor({
+                context: props.context,
+                modulo: props.modulo,
+                parameter: props.parameter,
+                name: props.function.name,
+                className: props.className,
+            }),
+        };
+    };
+    const writeParameters = (props) => {
+        const schema = props.function.parameters[0]?.schema ?? {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+        };
+        const result = LlmSchemaComposer.parameters(props.model)({
+            config: LlmSchemaComposer.defaultConfig(props.model),
+            components: props.components,
+            schema: {
+                ...schema,
+                title: schema.title ?? props.function.parameters[0]?.title,
+                description: schema.description ?? props.function.parameters[0]?.description,
+            },
+            accessor: props.accessor,
+        });
+        if (result.success === false) {
+            props.errors.push(...result.error.reasons.map((r) => `  - ${r.accessor}: ${r.message}`));
+            return null;
+        }
+        return result.value;
+    };
+    const writeOutput = (props) => {
+        if (props.schema === null)
+            return undefined;
+        const result = LlmSchemaComposer.schema(props.model)({
+            config: LlmSchemaComposer.defaultConfig(props.model),
+            components: props.components,
+            schema: props.schema,
+            $defs: props.parameters.$defs,
+            accessor: props.accessor,
+        });
+        if (result.success === false) {
+            props.errors.push(...result.error.reasons.map((r) => `  - ${r.accessor}: ${r.message}`));
+            return null;
+        }
+        return result.value;
+    };
+    const writeValidadtor = (props) => {
+        if (props.parameter === null)
+            return ValidateProgrammer.write({
+                ...props,
+                type: props.context.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+                config: {
+                    equals: false,
+                },
+                name: undefined,
+            });
+        const type = props.parameter.tsType;
+        if (type === undefined)
+            // unreachable
+            throw new Error("Failed to write LLM application's function validator. You don't have to call `LlmApplicationOfValidator.write()` function by yourself, but only by the `typia.llm.applicationOfValidate()` function.");
+        return ValidateProgrammer.write({
+            ...props,
+            type: props.parameter.tsType,
+            config: {
+                equals: false,
+            },
+            name: props.className
+                ? `Parameters<${props.className}[${JSON.stringify(props.name)}]>[0]`
+                : undefined,
+        });
+    };
+})(LlmApplicationProgrammer || (LlmApplicationProgrammer = {}));
+const concatDescription = (p) => {
+    if (!p.summary?.length || !p.description?.length)
+        return p.summary ?? p.description;
+    const summary = p.summary.endsWith(".")
+        ? p.summary.slice(0, -1)
+        : p.summary;
+    return p.description.startsWith(summary)
+        ? p.description
+        : summary + ".\n\n" + p.description;
+};
+
+export { LlmApplicationProgrammer };
+//# sourceMappingURL=LlmApplicationProgrammer.mjs.map

package/lib/programmers/llm/LlmApplicationProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LlmApplicationProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/llm/LlmModelPredicator.mjs

@@ -0,0 +1,96 @@
+import { LlmSchemaComposer } from '@samchon/openapi/lib/composers/LlmSchemaComposer.mjs';
+import ts from 'typescript';
+import { MetadataCollection } from '../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../factories/MetadataFactory.mjs';
+import { TransformerError } from '../../transformers/TransformerError.mjs';
+
+var LlmModelPredicator;
+(function (LlmModelPredicator) {
+    LlmModelPredicator.getConfig = (props) => {
+        if (props.node === undefined)
+            return undefined;
+        const type = props.context.checker.getTypeFromTypeNode(props.node);
+        const collection = new MetadataCollection();
+        const result = MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+                absorb: true,
+                escape: false,
+                constant: true,
+                functional: false,
+            },
+            collection,
+            type,
+        });
+        if (result.success === false)
+            throw new TransformerError({
+                code: `typia.llm.${props.method}`,
+                message: `Failed to analyze generic argument "Config".`,
+            });
+        const meta = result.data;
+        if (meta.size() !== 1 ||
+            meta.objects.length !== 1 ||
+            meta.nullable === true ||
+            meta.isRequired() === false)
+            throw new TransformerError({
+                code: `typia.llm.${props.method}`,
+                message: `Invalid generic argument "Config". It must be a literal object type.`,
+            });
+        const obj = meta.objects[0];
+        if (obj.type.properties.some((p) => p.key.isSoleLiteral() === false))
+            throw new TransformerError({
+                code: `typia.llm.${props.method}`,
+                message: `Invalid generic argument "Config". It must be a literal object type. Do not allow dynamic properties.`,
+            });
+        else if (obj.type.properties.some((p) => p.value.size() !== 1 ||
+            p.value.constants.length !== 1 ||
+            p.value.nullable === true ||
+            p.value.isRequired() === false))
+            throw new TransformerError({
+                code: `typia.llm.${props.method}`,
+                message: `Invalid generic argument "Config". It must be a literal object type. Do not allow variable type.`,
+            });
+        const config = {};
+        for (const prop of obj.type.properties) {
+            const key = prop.key.getSoleLiteral();
+            const value = prop.value.constants[0].values[0].value;
+            if (typeof value === "bigint")
+                throw new TransformerError({
+                    code: `typia.llm.${props.method}`,
+                    message: `Invalid generic argument "Config". It must be a literal object type. Do not allow bigint.`,
+                });
+            config[key] = value;
+        }
+        return config;
+    };
+    LlmModelPredicator.getModel = (props) => {
+        if (props.node === undefined)
+            throw new TransformerError({
+                code: `typia.llm.${props.method}`,
+                message: `generic argument "Model" must be specified.`,
+            });
+        // CHECK LITERAL TYPE
+        const type = props.checker.getTypeFromTypeNode(props.node);
+        if (!type.isLiteral() &&
+            (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0)
+            throw new TransformerError({
+                code: `typia.llm.${props.method}`,
+                message: `generic argument "Model" must be constant.`,
+            });
+        // GET VALUE AND VALIDATE IT
+        const value = type.isLiteral()
+            ? type.value
+            : props.checker.typeToString(type);
+        if (typeof value !== "string" ||
+            LlmSchemaComposer.defaultConfig(value) === undefined)
+            throw new TransformerError({
+                code: "typia.llm.schema",
+                message: `invalid value on generic argument "Model".`,
+            });
+        return value;
+    };
+})(LlmModelPredicator || (LlmModelPredicator = {}));
+
+export { LlmModelPredicator };
+//# sourceMappingURL=LlmModelPredicator.mjs.map

package/lib/programmers/llm/LlmModelPredicator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LlmModelPredicator.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/llm/LlmParametersProgrammer.mjs

@@ -0,0 +1,65 @@
+import { OpenApiTypeChecker } from '@samchon/openapi';
+import { LlmSchemaComposer } from '@samchon/openapi/lib/composers/LlmSchemaComposer.mjs';
+import { TransformerError } from '../../transformers/TransformerError.mjs';
+import { JsonSchemasProgrammer } from '../json/JsonSchemasProgrammer.mjs';
+import { LlmSchemaProgrammer } from './LlmSchemaProgrammer.mjs';
+
+var LlmParametersProgrammer;
+(function (LlmParametersProgrammer) {
+    LlmParametersProgrammer.write = (props) => {
+        const collection = JsonSchemasProgrammer.write({
+            version: "3.1",
+            metadatas: [props.metadata],
+        });
+        const schema = (() => {
+            const schema = collection.schemas[0];
+            if (OpenApiTypeChecker.isObject(schema))
+                return schema;
+            else if (OpenApiTypeChecker.isReference(schema)) {
+                const last = collection.components.schemas?.[schema.$ref.split("/").pop()];
+                if (last && OpenApiTypeChecker.isObject(last))
+                    return last;
+            }
+            throw new Error("Unreachable code. Failed to find the object schema.");
+        })();
+        const result = LlmSchemaComposer.parameters(props.model)({
+            config: {
+                ...LlmSchemaComposer.defaultConfig(props.model),
+                ...props.config,
+            },
+            components: collection.components,
+            schema,
+        });
+        if (result.success === false)
+            throw new TransformerError({
+                code: "typia.llm.parameters",
+                message: "failed to convert JSON schema to LLM schema.\n\n" +
+                    result.error.reasons
+                        .map((r) => `  - ${r.accessor}: ${r.message}`)
+                        .join("\n"),
+            });
+        return result.value;
+    };
+    LlmParametersProgrammer.validate = (props) => (metadata, explore) => {
+        const output = [];
+        if (explore.top === true) {
+            if (metadata.objects.length === 0)
+                output.push("LLM parameters must be an object type.");
+            else if (metadata.objects.length !== 1 || metadata.size() > 1)
+                output.push("LLM parameters must be a single object type.");
+            else {
+                if (metadata.objects[0].type.properties.some((p) => p.key.isSoleLiteral() === false))
+                    output.push("LLM parameters must not have dynamic keys.");
+                if (metadata.nullable)
+                    output.push("LLM parameters must be a non-nullable object type.");
+                if (metadata.isRequired() === false)
+                    output.push("LLM parameters must be a non-undefined object type.");
+            }
+        }
+        output.push(...LlmSchemaProgrammer.validate(props)(metadata));
+        return output;
+    };
+})(LlmParametersProgrammer || (LlmParametersProgrammer = {}));
+
+export { LlmParametersProgrammer };
+//# sourceMappingURL=LlmParametersProgrammer.mjs.map

package/lib/programmers/llm/LlmParametersProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LlmParametersProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}