github.com/mailru/activerecord@v1.12.2/internal/pkg/generator/tmpl/meta.tmpl

package repository

import (
    "fmt"
    "github.com/mailru/activerecord/pkg/octopus"
)

type SpaceMeta struct {
    PackageName string
    Unpacker func(ctx context.Context, tuple octopus.TupleData) (any, error)
    FixtureUnpacker func(ctx context.Context, source []byte) ([]any, error)
    Fields []FieldMeta
    PK IndexMeta
    Indexes map[string]IndexMeta
}

type IndexMeta struct {
    Name string
    Unpacker func(packedKeys [][][]byte) (any, error)
}

type FieldMeta struct {
    Name string
    Unpacker func(packedField []byte) (any, error)
}

type NSPackage map[string]SpaceMeta

func (ns NSPackage) meta(n uint32) (SpaceMeta, bool) {
	v, ok := ns[strconv.Itoa(int(n))]
	return v, ok
}

{{ $nss := .Namespaces }}
var NamespacePackages = NSPackage {
{{ range $_, $ns := $nss -}}
    {{ $serializers := $ns.SerializerMap -}}
    "{{ $ns.Namespace.ObjectName }}": {
        PackageName: "{{ $ns.Namespace.PackageName }}",
        Unpacker: func(ctx context.Context, tuple octopus.TupleData) (any, error) { 
            obj, err := {{ $ns.Namespace.PackageName }}.TupleToStruct(ctx, tuple)
            if err != nil {
                return nil, fmt.Errorf("can't decode tuple: %s", err)
            }

            return {{ $ns.Namespace.PackageName }}.MarshalFixtures([]*{{ $ns.Namespace.PackageName }}.{{ $ns.Namespace.PublicName }}{obj})
        },
		FixtureUnpacker: func(ctx context.Context, source []byte) (res []any, err error) {
            fxts, err := {{ $ns.Namespace.PackageName }}.UnmarshalFixtures(source)
            if err != nil {
                return nil, fmt.Errorf("can't decode tuple: %s", err)
            }

            for _, v := range fxts {
                res = append(res, v)
            }

            return
		},
        Fields: []FieldMeta{
            {{- range $_, $field := $ns.Fields }}
            {{ $sname := $field.Serializer.Name }}
            {
                Name: "{{ $field.Name }}",
                Unpacker: func(packedField []byte) (any, error){
                    {{ if ne $sname "" -}}
                    field, err :=  {{ $ns.Namespace.PackageName }}.Unpack{{ $field.Name }}(bytes.NewReader(packedField))
                    if err != nil {
                        return nil, err
                    }

                    return {{ $ns.Namespace.PackageName }}.Marshal{{ $field.Name }}(field)
                    {{- else }}
                    return {{ $ns.Namespace.PackageName }}.Unpack{{ $field.Name }}(bytes.NewReader(packedField))
                    {{- end }}
                },
            },
            {{- end }}
        },
        Indexes: map[string]IndexMeta{
        {{ if $ns.Indexes }}
        {{- $pk := index $ns.Indexes 0 }}
        {{- range $num, $ind := $ns.Indexes }}
            {{- if $ind.Primary }}{{ $pk = $ind }}{{ end }}
            "{{ $ind.Num }}.{{ len $ind.Fields }}": {
                Name: "{{ $ind.Name }}",
                Unpacker: func(packedKeys [][][]byte) (any, error) { return {{ $ns.Namespace.PackageName }}.UnpackKeyIndex{{ $ind.Name }}(packedKeys)},
            },
        {{- end }}
        {{- end }}
        },
        PK: IndexMeta{
            {{ if $ns.Indexes }}
            {{- $pk := index $ns.Indexes 0 }}
            Name: "{{ $pk.Name }}",
            Unpacker: func(packedKeys [][][]byte) (any, error) { return {{ $ns.Namespace.PackageName }}.UnpackKeyIndex{{ $pk.Name }}(packedKeys)},
            {{- end }}
        },
    },
{{ end }}
}

func (n NSPackage) GetSelectDebugInfo(ns uint32, indexnum uint32, offset uint32, limit uint32, keys [][][]byte, fixture ...octopus.SelectMockFixture) string {
	spacemeta, ex := n.meta(ns)
	if !ex {
		return fmt.Sprintf("unknown space %d, index: %d, offset: %d, limit: %d, Keys: %+v", ns, indexnum, offset, limit, keys)
	}

	fmtStr := "\n" + n.formatSelectMockFixture(ns, spacemeta, indexnum, offset, limit, keys) + "\n"
	fmtStr = fmt.Sprintf("%s\n--------------Installed 'Select' fixtures %s --------------\n", fmtStr, spacemeta.PackageName)
	for _, f := range fixture {
		fmtStr = fmtStr + "\n" + n.formatSelectMockFixture(ns, spacemeta, f.Indexnum, f.Offset, f.Limit, f.Keys) + " \n"

		for _, tuple := range f.RespTuples {
			strRespObj, err := spacemeta.Unpacker(context.TODO(), tuple)
			if err != nil {
				return fmt.Sprintf("Space: %d (%s), tuple: %+v (err unpack: %s)", ns, spacemeta.PackageName, tuple, err)
			}

			fmtStr = fmtStr + "\n" + fmt.Sprintf("%s", strRespObj) + "\n"

		}
	}

	fmtStr =  fmt.Sprintf("%s\n--------------End Installed 'Select' fixtures %s-----------\n\n\n\n", fmtStr, spacemeta.PackageName)

	return fmtStr
}

func (n NSPackage) formatSelectMockFixture(ns uint32, spacemeta SpaceMeta, indexnum uint32, offset uint32, limit uint32, keys [][][]byte) string {
    if len(keys) == 0 {
        return fmt.Sprintf("Space: %d (%s), index: %d, offset: %d, limit: %d, Empty Key Values", ns, spacemeta.PackageName, indexnum, offset, limit)
    }

	ind, ex := spacemeta.Indexes[fmt.Sprintf("%d.%d", indexnum, len(keys[0]))]
	if !ex {
		return fmt.Sprintf("space %d (%s), unknown index: %d (%d.%d), offset: %d, limit: %d, Keys: %+v", ns, spacemeta.PackageName, indexnum, indexnum, len(keys[0]), offset, limit, keys)
	}

	unpackedKeys, err := ind.Unpacker(keys)
	if err != nil {
		return fmt.Sprintf("Space: %d (%s), index: %d (%s), offset: %d, limit: %d, Keys: %+v (error unpack: %s)", ns, spacemeta.PackageName, indexnum, ind.Name, offset, limit, keys, err)
	}

	return fmt.Sprintf("Space: %d (%s), index: %d (%s), offset: %d, limit: %d, Keys: %+v", ns, spacemeta.PackageName, indexnum, ind.Name, offset, limit, unpackedKeys)
}

func (n NSPackage) GetUpdateDebugInfo(ns uint32, primaryKey [][]byte, updateOps []octopus.Ops, fixture ...octopus.UpdateMockFixture) string {
	spacemeta, ex := n.meta(ns)
	if !ex {
		return fmt.Sprintf("unknown space %d, primaryKey: %+v, updateOps: %+v", ns, primaryKey, updateOps)
	}

	fmtStr := "\n" + n.formatUpdateMockFixture(ns, spacemeta, primaryKey, updateOps) + "\n"
	fmtStr = fmt.Sprintf("%s\n--------------Installed 'Update' fixtures %s --------------\n", fmtStr, spacemeta.PackageName)
	for _, f := range fixture {
		fmtStr = fmtStr + "\n" + n.formatUpdateMockFixture(ns, spacemeta, f.PrimaryKey, f.UpdateOps) + "\n"
	}

	fmtStr =  fmt.Sprintf("%s\n--------------End Installed 'Update' fixtures %s-----------\n\n\n\n", fmtStr, spacemeta.PackageName)

	return fmtStr
}

func (n NSPackage) formatUpdateMockFixture(ns uint32, spacemeta SpaceMeta, primaryKey [][]byte, updateOps []octopus.Ops) string {
	unpackedKeys, err := spacemeta.PK.Unpacker([][][]byte{primaryKey})
	if err != nil {
		return fmt.Sprintf("Space: %d (%s), primaryKey: %+v, updateOps: %+v (error unpack: %s)", ns, spacemeta.PackageName, primaryKey, updateOps, err)
	}

	updateFields := ""

	for _, op := range updateOps {
		val, err := spacemeta.Fields[op.Field].Unpacker(op.Value)
		if err != nil {
			val = fmt.Sprintf("% X (can't unpack: %s)", op.Value, err)
		}

		updateFields += fmt.Sprintf("%s %s <= `%v`; ", octopus.GetOpCodeName(op.Op), spacemeta.Fields[op.Field].Name, val)
	}

	return fmt.Sprintf("Space: %d (%s), primaryKey: %s (%+v), updateOps: %s", ns, spacemeta.PackageName, spacemeta.PK.Name, unpackedKeys, updateFields)
}

func (n NSPackage) GetDeleteDebugInfo(ns uint32, primaryKey [][]byte, fixture ...octopus.DeleteMockFixture) string {
	spacemeta, ex := n.meta(ns)
	if !ex {
		return fmt.Sprintf("unknown space %d, primaryKey: %+v", ns, primaryKey)
	}

	fmtStr := "\n" + n.formatDeleteMockFixture(ns, spacemeta, primaryKey) + "\n"
	fmtStr = fmt.Sprintf("%s\n--------------Installed 'Delete' fixtures %s --------------\n", fmtStr, spacemeta.PackageName)
	for _, f := range fixture {
		fmtStr = fmtStr + "\n" + n.formatDeleteMockFixture(ns, spacemeta, f.PrimaryKey) + "\n"
	}

	fmtStr =  fmt.Sprintf("%s\n--------------End Installed 'Delete' fixtures %s-----------\n\n\n\n", fmtStr, spacemeta.PackageName)

	return fmtStr
}

func (n NSPackage) formatDeleteMockFixture(ns uint32, spacemeta SpaceMeta, primaryKey [][]byte) string {
	unpackedKeys, err := spacemeta.PK.Unpacker([][][]byte{primaryKey})
	if err != nil {
		return fmt.Sprintf("Space: %d (%s), primaryKey: %+v (error unpack: %s)", ns, spacemeta.PackageName, primaryKey, err)
	}

	return fmt.Sprintf("Space: %d (%s), primaryKey: %s (%+v)", ns, spacemeta.PackageName, spacemeta.PK.Name, unpackedKeys)
}

func (n NSPackage) GetInsertDebugInfo(ns uint32, needRetVal bool, insertMode octopus.InsertMode, tuple octopus.TupleData, fixture ...octopus.InsertMockFixture) string {
	strMode := octopus.GetInsertModeName(insertMode)

	spacemeta, ex := n.meta(ns)
	if !ex {
		return fmt.Sprintf("unknown space %d, insertMode: %s, tuple: %+v", ns, strMode, tuple)
	}

	fmtStr := "\n" + n.formatInsertMockFixture(ns, spacemeta, needRetVal, insertMode, tuple) + "\n"
	fmtStr = fmt.Sprintf("%s\n--------------Installed 'Insert' fixtures %s --------------\n", fmtStr, spacemeta.PackageName)
	for _, f := range fixture {
		fmtStr = fmtStr + "\n" + n.formatInsertMockFixture(ns, spacemeta, f.NeedRetVal, f.InsertMode, f.Tuple) + "\n"
	}

	fmtStr =  fmt.Sprintf("%s\n--------------End Installed 'Insert' fixtures %s------------\n\n\n\n", fmtStr, spacemeta.PackageName)

	return fmtStr
}

func (n NSPackage) formatInsertMockFixture(ns uint32, spacemeta SpaceMeta, needRetVal bool, insertMode octopus.InsertMode, tuple octopus.TupleData) string {
	strMode := octopus.GetInsertModeName(insertMode)

	strObj, err := spacemeta.Unpacker(context.TODO(), tuple)
	if err != nil {
		return fmt.Sprintf("Space: %d (%s), insertMode: %s, tuple: %+v (err unpack: %s)", ns, spacemeta.PackageName, strMode, tuple, err)
	}

	return fmt.Sprintf("Space: %d (%s), insertMode: %s, tuple: \n%s", ns, spacemeta.PackageName, strMode, strObj)
}


func (n NSPackage) GetCallDebugInfo(ns string, args [][]byte, fixture ...octopus.CallMockFixture) string {
	spacemeta, ex := n[ns]
	if !ex {
		return fmt.Sprintf("unknown procedure %s, arguments: %+v", ns, args)
	}

	fmtStr := "\n" + n.formatCallMockFixture(ns, args) + "\n"
	fmtStr = fmt.Sprintf("%s\n--------------Installed 'Call' fixtures %s --------------\n", fmtStr, spacemeta.PackageName)
	for _, f := range fixture {
		fmtStr = fmtStr + "\n" + n.formatCallMockFixture(ns, f.Args) + " \n"

		for _, tuple := range f.RespTuples {
			strRespObj, err := spacemeta.Unpacker(context.TODO(), tuple)
			if err != nil {
				return fmt.Sprintf("Procedure: %s, tuple: %+v (err unpack: %s)", ns, tuple, err)
			}

			fmtStr = fmtStr + "\n" + fmt.Sprintf("%s", strRespObj) + "\n"
		}
	}

	fmtStr = fmt.Sprintf("%s\n--------------End Installed 'Call' fixtures %s-----------\n\n\n\n", fmtStr, spacemeta.PackageName)

	return fmtStr
}

func (n NSPackage) formatCallMockFixture(ns string, args [][]byte) string {
	var unpackedArgs []string

	for _, arg := range args {
		unpackedArgs = append(unpackedArgs, string(arg))
	}

	return fmt.Sprintf("Procedure: %s, arguments: %s", ns, unpackedArgs)
}