typia 13.0.0-dev.20260427-2 → 13.0.0-dev.20260430

package/native/core/programmers/protobuf/ProtobufValidateEncodeProgrammer.go

@@ -0,0 +1,145 @@
+package protobuf
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+)
+
+type protobufValidateEncodeProgrammerNamespace struct{}
+
+var ProtobufValidateEncodeProgrammer = protobufValidateEncodeProgrammerNamespace{}
+
+type ProtobufValidateEncodeProgrammer_IProps struct {
+	Context nativecontext.ITypiaContext
+	Modulo  *shimast.Node
+	Type    *shimchecker.Type
+	Name    *string
+	Init    *shimast.Node
+}
+
+type ProtobufValidateEncodeProgrammer_DecomposeProps struct {
+	Context nativecontext.ITypiaContext
+	Modulo  *shimast.Node
+	Functor *nativehelpers.FunctionProgrammer
+	Type    *shimchecker.Type
+	Name    *string
+}
+
+var protobufValidateEncodeProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (protobufValidateEncodeProgrammerNamespace) Decompose(props ProtobufValidateEncodeProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
+	validateContext := props.Context
+	functional := false
+	finite := true
+	validateContext.Options.Functional = &functional
+	validateContext.Options.Finite = &finite
+	validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
+		Context: validateContext,
+		Modulo:  props.Modulo,
+		Functor: props.Functor,
+		Type:    props.Type,
+		Name:    props.Name,
+		Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
+	})
+	encode := ProtobufEncodeProgrammer.Decompose(ProtobufEncodeProgrammer_DecomposeProps{
+		Context: props.Context,
+		Modulo:  props.Modulo,
+		Functor: props.Functor,
+		Type:    props.Type,
+		Name:    props.Name,
+	})
+	encodeType := protobufAssertEncodeProgrammer_returnType(encode.Arrow, protobufValidateEncodeProgrammer_factory.NewTypeReferenceNode(protobufValidateEncodeProgrammer_factory.NewIdentifier("Uint8Array"), nil))
+	statements := []*shimast.Node{}
+	statements = append(statements, validate.Statements...)
+	statements = append(statements, encode.Statements...)
+	statements = append(statements,
+		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__validate", Value: validate.Arrow}),
+		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__encode", Value: encode.Arrow}),
+	)
+	return nativeinternal.FeatureProgrammer_IDecomposed{
+		Functions:  protobufAssertEncodeProgrammer_merge(validate.Functions, encode.Functions),
+		Statements: statements,
+		Arrow: protobufValidateEncodeProgrammer_factory.NewArrowFunction(
+			nil,
+			nil,
+			protobufValidateEncodeProgrammer_factory.NewNodeList([]*shimast.Node{
+				nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
+			}),
+			protobufValidateEncodeProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+				File:      "typia",
+				Name:      "IValidation",
+				Arguments: []*shimast.TypeNode{encodeType},
+			}),
+			nil,
+			protobufValidateEncodeProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			protobufValidateEncodeProgrammer_factory.NewBlock(protobufValidateEncodeProgrammer_factory.NewNodeList([]*shimast.Node{
+				nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+					Name: "result",
+					Value: protobufValidateEncodeProgrammer_factory.NewAsExpression(
+						protobufValidateEncodeProgrammer_factory.NewCallExpression(
+							protobufValidateEncodeProgrammer_factory.NewIdentifier("__validate"),
+							nil,
+							nil,
+							protobufValidateEncodeProgrammer_factory.NewNodeList([]*shimast.Node{protobufValidateEncodeProgrammer_factory.NewIdentifier("input")}),
+							shimast.NodeFlagsNone,
+						),
+						nativefactories.TypeFactory.Keyword("any"),
+					),
+				}),
+				protobufValidateEncodeProgrammer_factory.NewIfStatement(
+					protobufValidateEncodeProgrammer_factory.NewIdentifier("result.success"),
+					protobufValidateEncodeProgrammer_factory.NewExpressionStatement(
+						protobufValidateEncodeProgrammer_factory.NewBinaryExpression(
+							nil,
+							protobufValidateEncodeProgrammer_factory.NewIdentifier("result.data"),
+							nil,
+							protobufValidateEncodeProgrammer_factory.NewToken(shimast.KindEqualsToken),
+							protobufValidateEncodeProgrammer_factory.NewCallExpression(
+								protobufValidateEncodeProgrammer_factory.NewIdentifier("__encode"),
+								nil,
+								nil,
+								protobufValidateEncodeProgrammer_factory.NewNodeList([]*shimast.Node{protobufValidateEncodeProgrammer_factory.NewIdentifier("input")}),
+								shimast.NodeFlagsNone,
+							),
+						),
+					),
+					nil,
+				),
+				protobufValidateEncodeProgrammer_factory.NewReturnStatement(protobufValidateEncodeProgrammer_factory.NewIdentifier("result")),
+			}), true),
+		),
+	}
+}
+
+func (protobufValidateEncodeProgrammerNamespace) Write(props ProtobufValidateEncodeProgrammer_IProps) *shimast.Node {
+	functor := nativehelpers.NewFunctionProgrammer(protobufAssertEncodeProgrammer_method_text(props.Modulo))
+	result := ProtobufValidateEncodeProgrammer.Decompose(ProtobufValidateEncodeProgrammer_DecomposeProps{
+		Context: props.Context,
+		Modulo:  props.Modulo,
+		Functor: functor,
+		Type:    props.Type,
+		Name:    props.Name,
+	})
+	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+		Modulo:  props.Modulo,
+		Functor: functor,
+		Result:  result,
+	})
+}
+
+func protobufValidateEncodeProgrammer_import_type(context nativecontext.ITypiaContext, props nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node {
+	if importer, ok := context.Importer.(interface {
+		Type(nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node
+	}); ok {
+		return importer.Type(props)
+	}
+	if str, ok := props.Name.(string); ok {
+		return protobufValidateEncodeProgrammer_factory.NewTypeReferenceNode(protobufValidateEncodeProgrammer_factory.NewIdentifier(str), protobufValidateEncodeProgrammer_factory.NewNodeList(props.Arguments))
+	}
+	return props.Name.(*shimast.Node)
+}

package/native/core/programmers/protobuf/index.go

@@ -0,0 +1 @@
+package protobuf

package/native/core/schemas/index.go

@@ -0,0 +1 @@
+package schemas

package/native/core/schemas/metadata/IMetadataDictionary.go

@@ -0,0 +1,8 @@
+package metadata
+
+type IMetadataDictionary struct {
+	Objects map[string]*MetadataObjectType
+	Aliases map[string]*MetadataAliasType
+	Arrays  map[string]*MetadataArrayType
+	Tuples  map[string]*MetadataTupleType
+}

package/native/core/schemas/metadata/MetadataAlias.go

@@ -0,0 +1,28 @@
+package metadata
+
+type MetadataAlias struct {
+	Type  *MetadataAliasType
+	Tags  [][]IMetadataTypeTag
+	name_ string
+}
+
+func MetadataAlias_create(props MetadataAlias) *MetadataAlias {
+	return &MetadataAlias{
+		Type: props.Type,
+		Tags: cloneTagMatrix(props.Tags),
+	}
+}
+
+func (obj *MetadataAlias) GetName() string {
+	if obj.name_ == "" {
+		obj.name_ = taggedName(obj.Type.Name, obj.Tags)
+	}
+	return obj.name_
+}
+
+func (obj *MetadataAlias) ToJSON() IMetadataSchema_IReference {
+	return IMetadataSchema_IReference{
+		Name: obj.Type.Name,
+		Tags: cloneTagMatrix(obj.Tags),
+	}
+}

package/native/core/schemas/metadata/MetadataAliasType.go

@@ -0,0 +1,52 @@
+package metadata
+
+type IMetadataSchema_IAliasType struct {
+	Name        string
+	Value       *IMetadataSchema
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	Recursive   bool
+	Nullables   []bool
+}
+
+type MetadataAliasType struct {
+	Name        string
+	Value       *MetadataSchema
+	Description *string
+	JsDocTags   []IJsDocTagInfo
+	Recursive   bool
+	Nullables   []bool
+}
+
+func MetadataAliasType_create(props MetadataAliasType) *MetadataAliasType {
+	return &MetadataAliasType{
+		Name:        props.Name,
+		Value:       props.Value,
+		Description: props.Description,
+		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+		Recursive:   props.Recursive,
+		Nullables:   append([]bool{}, props.Nullables...),
+	}
+}
+
+func MetadataAliasType__From_without_value(props IMetadataSchema_IAliasType) *MetadataAliasType {
+	return MetadataAliasType_create(MetadataAliasType{
+		Name:        props.Name,
+		Value:       nil,
+		Description: props.Description,
+		Recursive:   props.Recursive,
+		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+		Nullables:   append([]bool{}, props.Nullables...),
+	})
+}
+
+func (obj *MetadataAliasType) ToJSON() IMetadataSchema_IAliasType {
+	return IMetadataSchema_IAliasType{
+		Name:        obj.Name,
+		Value:       obj.Value.ToJSON(),
+		Description: obj.Description,
+		Recursive:   obj.Recursive,
+		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+		Nullables:   append([]bool{}, obj.Nullables...),
+	}
+}

package/native/core/schemas/metadata/MetadataApplication.go

@@ -0,0 +1,41 @@
+package metadata
+
+type IMetadataSchemaCollection struct {
+	Schemas    []*IMetadataSchema
+	Components IMetadataComponents
+}
+
+type MetadataApplication struct {
+	Schemas    []*MetadataSchema
+	Components *MetadataComponents
+}
+
+func MetadataApplication_create(props MetadataApplication) *MetadataApplication {
+	return &MetadataApplication{
+		Schemas:    props.Schemas,
+		Components: props.Components,
+	}
+}
+
+func MetadataApplication_from(app IMetadataSchemaCollection) *MetadataApplication {
+	components := MetadataComponents_from(app.Components)
+	metadatas := make([]*MetadataSchema, 0, len(app.Schemas))
+	for _, metadata := range app.Schemas {
+		metadatas = append(metadatas, MetadataSchema_from(metadata, components.Dictionary))
+	}
+	return MetadataApplication_create(MetadataApplication{
+		Schemas:    metadatas,
+		Components: components,
+	})
+}
+
+func (app *MetadataApplication) ToJSON() IMetadataSchemaCollection {
+	schemas := make([]*IMetadataSchema, 0, len(app.Schemas))
+	for _, schema := range app.Schemas {
+		schemas = append(schemas, schema.ToJSON())
+	}
+	return IMetadataSchemaCollection{
+		Schemas:    schemas,
+		Components: app.Components.ToJSON(),
+	}
+}

package/native/core/schemas/metadata/MetadataArray.go

@@ -0,0 +1,28 @@
+package metadata
+
+type MetadataArray struct {
+	Type  *MetadataArrayType
+	Tags  [][]IMetadataTypeTag
+	name_ string
+}
+
+func MetadataArray_create(props MetadataArray) *MetadataArray {
+	return &MetadataArray{
+		Type: props.Type,
+		Tags: cloneTagMatrix(props.Tags),
+	}
+}
+
+func (obj *MetadataArray) GetName() string {
+	if obj.name_ == "" {
+		obj.name_ = taggedName(obj.Type.Name, obj.Tags)
+	}
+	return obj.name_
+}
+
+func (obj *MetadataArray) ToJSON() IMetadataSchema_IReference {
+	return IMetadataSchema_IReference{
+		Name: obj.Type.Name,
+		Tags: cloneTagMatrix(obj.Tags),
+	}
+}

package/native/core/schemas/metadata/MetadataArrayType.go

@@ -0,0 +1,47 @@
+package metadata
+
+type IMetadataSchema_IArrayType struct {
+	Name      string
+	Value     *IMetadataSchema
+	Nullables []bool
+	Recursive bool
+	Index     *int
+}
+
+type MetadataArrayType struct {
+	Name      string
+	Value     *MetadataSchema
+	Nullables []bool
+	Recursive bool
+	Index     *int
+}
+
+func MetadataArrayType__From_without_value(props IMetadataSchema_IArrayType) *MetadataArrayType {
+	return MetadataArrayType_create(MetadataArrayType{
+		Name:      props.Name,
+		Value:     nil,
+		Index:     props.Index,
+		Recursive: props.Recursive,
+		Nullables: append([]bool{}, props.Nullables...),
+	})
+}
+
+func MetadataArrayType_create(props MetadataArrayType) *MetadataArrayType {
+	return &MetadataArrayType{
+		Name:      props.Name,
+		Value:     props.Value,
+		Index:     props.Index,
+		Recursive: props.Recursive,
+		Nullables: append([]bool{}, props.Nullables...),
+	}
+}
+
+func (obj *MetadataArrayType) ToJSON() IMetadataSchema_IArrayType {
+	return IMetadataSchema_IArrayType{
+		Name:      obj.Name,
+		Value:     obj.Value.ToJSON(),
+		Nullables: append([]bool{}, obj.Nullables...),
+		Recursive: obj.Recursive,
+		Index:     obj.Index,
+	}
+}

package/native/core/schemas/metadata/MetadataAtomic.go

@@ -0,0 +1,69 @@
+package metadata
+
+import "strings"
+
+type IMetadataSchema_IAtomic struct {
+	Type string
+	Tags [][]IMetadataTypeTag
+}
+
+type MetadataAtomic struct {
+	Type  string
+	Tags  [][]IMetadataTypeTag
+	name_ string
+}
+
+func MetadataAtomic_create(props MetadataAtomic) *MetadataAtomic {
+	return &MetadataAtomic{
+		Type: props.Type,
+		Tags: props.Tags,
+	}
+}
+
+func MetadataAtomic_from(json IMetadataSchema_IAtomic) *MetadataAtomic {
+	return MetadataAtomic_create(MetadataAtomic{
+		Type: json.Type,
+		Tags: json.Tags,
+	})
+}
+
+func (obj *MetadataAtomic) GetName() string {
+	if obj.name_ == "" {
+		obj.name_ = metadataAtomic_getName(obj)
+	}
+	return obj.name_
+}
+
+func (obj *MetadataAtomic) ToJSON() IMetadataSchema_IAtomic {
+	return IMetadataSchema_IAtomic{
+		Type: obj.Type,
+		Tags: obj.Tags,
+	}
+}
+
+func metadataAtomic_getName(obj *MetadataAtomic) string {
+	if len(obj.Tags) == 0 {
+		return obj.Type
+	}
+	if len(obj.Tags) == 1 {
+		row := []string{obj.Type}
+		for _, tag := range obj.Tags[0] {
+			row = append(row, tag.Name)
+		}
+		return "(" + strings.Join(row, " & ") + ")"
+	}
+	rows := make([]string, 0, len(obj.Tags))
+	for _, row := range obj.Tags {
+		names := make([]string, 0, len(row))
+		for _, tag := range row {
+			names = append(names, tag.Name)
+		}
+		str := strings.Join(names, " & ")
+		if len(row) == 1 {
+			rows = append(rows, str)
+		} else {
+			rows = append(rows, "("+str+")")
+		}
+	}
+	return "(" + obj.Type + " & (" + strings.Join(rows, " | ") + "))"
+}