typia 8.0.0 → 8.0.1

package/lib/programmers/http/HttpQueryProgrammer.mjs

@@ -0,0 +1,211 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { MetadataCollection } from '../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../factories/MetadataFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { MetadataArrayType } from '../../schemas/metadata/MetadataArrayType.mjs';
+import { TransformerError } from '../../transformers/TransformerError.mjs';
+import { Escaper } from '../../utils/Escaper.mjs';
+import { StringUtil } from '../../utils/StringUtil.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { HttpMetadataUtil } from '../helpers/HttpMetadataUtil.mjs';
+
+var HttpQueryProgrammer;
+(function (HttpQueryProgrammer) {
+    HttpQueryProgrammer.decompose = (props) => {
+        // ANALYZE TYPE
+        const collection = new MetadataCollection();
+        const result = MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+                escape: false,
+                constant: true,
+                absorb: true,
+                validate: (meta, explore) => HttpQueryProgrammer.validate(meta, explore, props.allowOptional),
+            },
+            collection,
+            type: props.type,
+        });
+        if (result.success === false)
+            throw TransformerError.from({
+                code: props.functor.method,
+                errors: result.errors,
+            });
+        // DO TRANSFORM
+        const object = result.data.objects[0].type;
+        const statements = decode_object({
+            context: props.context,
+            object,
+        });
+        return {
+            functions: {},
+            statements: [],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory.parameter("input", ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode("string"),
+                    props.context.importer.type({
+                        file: "typia",
+                        name: "IReadableURLSearchParams",
+                    }),
+                ])),
+            ], props.context.importer.type({
+                file: "typia",
+                name: "Resolved",
+                arguments: [
+                    ts.factory.createTypeReferenceNode(props.name ??
+                        TypeFactory.getFullName({
+                            checker: props.context.checker,
+                            type: props.type,
+                        })),
+                ],
+            }), undefined, ts.factory.createBlock(statements, true)),
+        };
+    };
+    HttpQueryProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpQueryProgrammer.decompose({
+            ...props,
+            functor,
+            allowOptional: !!props.allowOptional,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+    HttpQueryProgrammer.validate = (meta, explore, allowOptional = false) => {
+        const errors = [];
+        const insert = (msg) => errors.push(msg);
+        if (explore.top === true) {
+            // TOP MUST BE ONLY OBJECT
+            if (meta.objects.length !== 1 || meta.bucket() !== 1)
+                insert("only one object type is allowed.");
+            if (meta.nullable === true)
+                insert("query parameters cannot be null.");
+            if (meta.isRequired() === false) {
+                if (allowOptional === true) {
+                    const everyPropertiesAreOptional = meta.size() === 1 &&
+                        meta.objects.length === 1 &&
+                        meta.objects[0].type.properties.every((p) => p.value.isRequired() === false);
+                    if (everyPropertiesAreOptional === false)
+                        insert("query parameters can be optional only when every properties are optional.");
+                }
+                else
+                    insert("query parameters cannot be undefined.");
+            }
+        }
+        else if (explore.nested !== null &&
+            explore.nested instanceof MetadataArrayType) {
+            //----
+            // ARRAY
+            //----
+            const atomics = HttpMetadataUtil.atomics(meta);
+            const expected = meta.atomics.length +
+                meta.templates.length +
+                meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0);
+            if (atomics.size > 1)
+                insert("union type is not allowed in array.");
+            if (meta.size() !== expected)
+                insert("only atomic or constant types are allowed in array.");
+        }
+        else if (explore.object && explore.property !== null) {
+            //----
+            // COMMON
+            //----
+            // PROPERTY MUST BE SOLE
+            if (typeof explore.property === "object")
+                insert("dynamic property is not allowed.");
+            // DO NOT ALLOW TUPLE TYPE
+            if (meta.tuples.length)
+                insert("tuple type is not allowed.");
+            // DO NOT ALLOW UNION TYPE
+            if (HttpMetadataUtil.isUnion(meta))
+                insert("union type is not allowed.");
+            // DO NOT ALLOW NESTED OBJECT
+            if (meta.objects.length ||
+                meta.sets.length ||
+                meta.maps.length ||
+                meta.natives.length)
+                insert("nested object type is not allowed.");
+        }
+        return errors;
+    };
+    const decode_object = (props) => {
+        const input = ts.factory.createIdentifier("input");
+        const output = ts.factory.createIdentifier("output");
+        return [
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(input, ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createAsExpression(ts.factory.createCallExpression(props.context.importer.internal("httpQueryParseURLSearchParams"), undefined, [input]), props.context.importer.type({
+                file: "typia",
+                name: "IReadableURLSearchParams",
+            })))),
+            StatementFactory.constant({
+                name: "output",
+                value: ts.factory.createObjectLiteralExpression(props.object.properties.map((p) => decode_regular_property({
+                    context: props.context,
+                    property: p,
+                })), true),
+            }),
+            ts.factory.createReturnStatement(ts.factory.createAsExpression(output, TypeFactory.keyword("any"))),
+        ];
+    };
+    const decode_regular_property = (props) => {
+        const key = props.property.key.constants[0].values[0]
+            .value;
+        const value = props.property.value;
+        const [type, isArray] = value.atomics.length
+            ? [value.atomics[0].type, false]
+            : value.constants.length
+                ? [value.constants[0].type, false]
+                : value.templates.length
+                    ? ["string", false]
+                    : (() => {
+                        const meta = value.arrays[0]?.type.value ??
+                            value.tuples[0].type.elements[0];
+                        return meta.atomics.length
+                            ? [meta.atomics[0].type, true]
+                            : meta.templates.length
+                                ? ["string", true]
+                                : [meta.constants[0].type, true];
+                    })();
+        return ts.factory.createPropertyAssignment(Escaper.variable(key) ? key : ts.factory.createStringLiteral(key), isArray
+            ? decode_array({
+                context: props.context,
+                metadata: value,
+                input: ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(ts.factory.createIdentifier("input.getAll"), undefined, [ts.factory.createStringLiteral(key)]), "map"), undefined, [
+                    ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("elem")], undefined, undefined, decode_value({
+                        context: props.context,
+                        type,
+                        coalesce: false,
+                        input: ts.factory.createIdentifier("elem"),
+                    })),
+                ]),
+            })
+            : decode_value({
+                context: props.context,
+                type,
+                coalesce: value.nullable === false && value.isRequired() === false,
+                input: ts.factory.createCallExpression(ts.factory.createIdentifier("input.get"), undefined, [ts.factory.createStringLiteral(key)]),
+            }));
+    };
+    const decode_value = (props) => {
+        const call = ts.factory.createCallExpression(props.context.importer.internal(`httpQueryRead${StringUtil.capitalize(props.type)}`), undefined, [props.input]);
+        return props.coalesce
+            ? ts.factory.createBinaryExpression(call, ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), ts.factory.createIdentifier("undefined"))
+            : call;
+    };
+    const decode_array = (props) => props.metadata.nullable || props.metadata.isRequired() === false
+        ? ts.factory.createCallExpression(props.context.importer.internal("httpQueryReadArray"), undefined, [
+            props.input,
+            props.metadata.nullable
+                ? ts.factory.createNull()
+                : ts.factory.createIdentifier("undefined"),
+        ])
+        : props.input;
+})(HttpQueryProgrammer || (HttpQueryProgrammer = {}));
+
+export { HttpQueryProgrammer };
+//# sourceMappingURL=HttpQueryProgrammer.mjs.map

package/lib/programmers/http/HttpQueryProgrammer.mjs.map

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

package/lib/programmers/http/HttpValidateFormDataProgrammer.mjs

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+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 { HttpFormDataProgrammer } from './HttpFormDataProgrammer.mjs';
+
+var HttpValidateFormDataProgrammer;
+(function (HttpValidateFormDataProgrammer) {
+    HttpValidateFormDataProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+            },
+        });
+        const decode = HttpFormDataProgrammer.decompose(props);
+        return {
+            functions: {
+                ...validate.functions,
+                ...decode.functions,
+            },
+            statements: [
+                ...validate.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__decode",
+                    value: decode.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, decode.arrow.parameters, props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+            }), undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("__decode"), undefined, [ts.factory.createIdentifier("input")]),
+            ])),
+        };
+    };
+    HttpValidateFormDataProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpValidateFormDataProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(HttpValidateFormDataProgrammer || (HttpValidateFormDataProgrammer = {}));
+
+export { HttpValidateFormDataProgrammer };
+//# sourceMappingURL=HttpValidateFormDataProgrammer.mjs.map

package/lib/programmers/http/HttpValidateFormDataProgrammer.mjs.map

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

package/lib/programmers/http/HttpValidateHeadersProgrammer.mjs

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+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 { HttpHeadersProgrammer } from './HttpHeadersProgrammer.mjs';
+
+var HttpValidateHeadersProgrammer;
+(function (HttpValidateHeadersProgrammer) {
+    HttpValidateHeadersProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+            },
+        });
+        const decode = HttpHeadersProgrammer.decompose(props);
+        return {
+            functions: {
+                ...validate.functions,
+                ...decode.functions,
+            },
+            statements: [
+                ...validate.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__decode",
+                    value: decode.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, decode.arrow.parameters, props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+            }), undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("__decode"), undefined, [ts.factory.createIdentifier("input")]),
+            ])),
+        };
+    };
+    HttpValidateHeadersProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpValidateHeadersProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(HttpValidateHeadersProgrammer || (HttpValidateHeadersProgrammer = {}));
+
+export { HttpValidateHeadersProgrammer };
+//# sourceMappingURL=HttpValidateHeadersProgrammer.mjs.map

package/lib/programmers/http/HttpValidateHeadersProgrammer.mjs.map

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

package/lib/programmers/http/HttpValidateQueryProgrammer.mjs

@@ -0,0 +1,68 @@
+import ts from 'typescript';
+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 { HttpQueryProgrammer } from './HttpQueryProgrammer.mjs';
+
+var HttpValidateQueryProgrammer;
+(function (HttpValidateQueryProgrammer) {
+    HttpValidateQueryProgrammer.decompose = (props) => {
+        const validate = ValidateProgrammer.decompose({
+            ...props,
+            context: {
+                ...props.context,
+                options: {
+                    ...props.context.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            config: {
+                equals: false,
+            },
+        });
+        const decode = HttpQueryProgrammer.decompose(props);
+        return {
+            functions: {
+                ...validate.functions,
+                ...decode.functions,
+            },
+            statements: [
+                ...validate.statements,
+                StatementFactory.constant({
+                    name: "__validate",
+                    value: validate.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__decode",
+                    value: decode.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, decode.arrow.parameters, props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+            }), undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("__validate"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("__decode"), undefined, [ts.factory.createIdentifier("input")]),
+            ])),
+        };
+    };
+    HttpValidateQueryProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = HttpValidateQueryProgrammer.decompose({
+            ...props,
+            functor,
+            allowOptional: !!props.allowOptional,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(HttpValidateQueryProgrammer || (HttpValidateQueryProgrammer = {}));
+
+export { HttpValidateQueryProgrammer };
+//# sourceMappingURL=HttpValidateQueryProgrammer.mjs.map

package/lib/programmers/http/HttpValidateQueryProgrammer.mjs.map

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

package/lib/programmers/internal/check_array_length.mjs

@@ -0,0 +1,30 @@
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+
+/**
+ * @internal
+ */
+const check_array_length = (props) => {
+    const conditions = check_array_type_tags(props);
+    return {
+        expected: props.array.getName(),
+        expression: null,
+        conditions,
+    };
+};
+/**
+ * @internal
+ */
+const check_array_type_tags = (props) => props.array.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) => row.map((tag) => ({
+    expected: `Array<> & ${tag.name}`,
+    expression: ExpressionFactory.transpile({
+        transformer: props.context.transformer,
+        importer: props.context.importer,
+        script: tag.validate,
+    })(props.input),
+})));
+
+export { check_array_length };
+//# sourceMappingURL=check_array_length.mjs.map

package/lib/programmers/internal/check_array_length.mjs.map

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

package/lib/programmers/internal/check_bigint.mjs

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+
+/**
+ * @internal
+ */
+const check_bigint = (props) => {
+    const conditions = check_bigint_type_tags(props);
+    return {
+        expected: props.atomic.getName(),
+        expression: ts.factory.createStrictEquality(ts.factory.createStringLiteral("bigint"), ts.factory.createTypeOfExpression(props.input)),
+        conditions,
+    };
+};
+/**
+ * @internal
+ */
+const check_bigint_type_tags = (props) => props.atomic.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) => row.map((tag) => ({
+    expected: `bigint & ${tag.name}`,
+    expression: ExpressionFactory.transpile({
+        transformer: props.context.transformer,
+        importer: props.context.importer,
+        script: tag.validate,
+    })(props.input),
+})));
+
+export { check_bigint };
+//# sourceMappingURL=check_bigint.mjs.map

package/lib/programmers/internal/check_bigint.mjs.map

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

package/lib/programmers/internal/check_dynamic_key.mjs

@@ -0,0 +1,91 @@
+import ts from 'typescript';
+import { check_bigint } from './check_bigint.mjs';
+import { check_number } from './check_number.mjs';
+import { check_string } from './check_string.mjs';
+import { check_template } from './check_template.mjs';
+
+/**
+ * @internal
+ */
+const check_dynamic_key = (props) => {
+    // IF PURE STRING EXISTS, THEN SKIP VALIDATION
+    if ((props.metadata.atomics.length !== 0 &&
+        props.metadata.atomics.some((a) => a.type === "string" &&
+            a.tags.filter((row) => row.every((t) => t.validate !== undefined))
+                .length === 0)) ||
+        (props.metadata.natives.length !== 0 &&
+            props.metadata.natives.some((native) => native.name === "String")))
+        return ts.factory.createTrue();
+    const conditions = [];
+    // NULLISH COALESCING
+    if (props.metadata.nullable === true)
+        conditions.push(ts.factory.createStrictEquality(ts.factory.createStringLiteral("null"), props.input));
+    if (props.metadata.isRequired() === false)
+        conditions.push(ts.factory.createStrictEquality(ts.factory.createStringLiteral("undefined"), props.input));
+    // ATOMICS
+    for (const atom of props.metadata.atomics)
+        if (atom.type === "boolean")
+            conditions.push(ts.factory.createLogicalOr(ts.factory.createStrictEquality(ts.factory.createStringLiteral("false"), props.input), ts.factory.createStrictEquality(ts.factory.createStringLiteral("true"), props.input)));
+        else if (atom.type === "bigint")
+            conditions.push(ts.factory.createLogicalAnd(ts.factory.createCallExpression(props.context.importer.internal("isBigintString"), undefined, [props.input]), atomist(check_bigint({
+                context: props.context,
+                atomic: atom,
+                input: ts.factory.createCallExpression(ts.factory.createIdentifier("BigInt"), undefined, [props.input]),
+            }))));
+        else if (atom.type === "number")
+            conditions.push(atomist(check_number({
+                context: props.context,
+                numeric: true,
+                atomic: atom,
+                input: ts.factory.createCallExpression(ts.factory.createIdentifier("Number"), undefined, [props.input]),
+            })));
+        else
+            conditions.push(atomist(check_string({
+                context: props.context,
+                atomic: atom,
+                input: props.input,
+            })));
+    // CONSTANTS
+    for (const constant of props.metadata.constants)
+        for (const { value } of constant.values)
+            conditions.push(ts.factory.createStrictEquality(ts.factory.createStringLiteral(String(value)), props.input));
+    // TEMPLATES
+    if (!!props.metadata.templates.length)
+        conditions.push(atomist(check_template({
+            templates: props.metadata.templates,
+            input: props.input,
+        })));
+    // NATIVES
+    for (const native of props.metadata.natives)
+        if (native.name === "Boolean")
+            conditions.push(ts.factory.createLogicalOr(ts.factory.createStrictEquality(ts.factory.createStringLiteral("false"), props.input), ts.factory.createStrictEquality(ts.factory.createStringLiteral("true"), props.input)));
+        else if (native.name === "BigInt")
+            conditions.push(ts.factory.createCallExpression(props.context.importer.internal("isBigintString"), undefined, [props.input]));
+        else if (native.name === "Number")
+            conditions.push(ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createCallExpression(ts.factory.createIdentifier("Number.isNaN"), undefined, [
+                ts.factory.createCallExpression(ts.factory.createIdentifier("Number"), undefined, [props.input]),
+            ])));
+    return conditions.length === 0
+        ? ts.factory.createTrue()
+        : conditions.length === 1
+            ? conditions[0]
+            : conditions.reduce(ts.factory.createLogicalOr);
+};
+/**
+ * @internal
+ */
+const atomist = (entry) => [
+    ...(entry.expression ? [entry.expression] : []),
+    ...(entry.conditions.length === 0
+        ? []
+        : [
+            entry.conditions
+                .map((set) => set
+                .map((s) => s.expression)
+                .reduce((a, b) => ts.factory.createLogicalAnd(a, b)))
+                .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+        ]),
+].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+
+export { check_dynamic_key };
+//# sourceMappingURL=check_dynamic_key.mjs.map

package/lib/programmers/internal/check_dynamic_key.mjs.map

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