sonamu 0.8.13 → 0.8.15

package/dist/types/__tests__/entity-json-schema-search-text.test.js

@@ -0,0 +1,256 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import { EntityJsonSchema, isSearchTextJsonSourceZodType, TemplateOptions } from "../types.js";
+function createBaseEntity() {
+    return {
+        id: "SearchTextTest",
+        title: "SearchText Test",
+        table: "search_text_tests",
+        props: [
+            {
+                name: "id",
+                type: "integer"
+            },
+            {
+                name: "title",
+                type: "string"
+            },
+            {
+                name: "tags",
+                type: "string[]"
+            },
+            {
+                name: "aliases",
+                type: "json",
+                id: "StringArray"
+            },
+            {
+                name: "search_text",
+                type: "searchText",
+                sourceColumns: [
+                    {
+                        name: "title",
+                        caseInsensitive: true
+                    }
+                ]
+            }
+        ],
+        indexes: [
+            {
+                type: "index",
+                name: "search_text_tests_search_text_index",
+                using: "gin",
+                columns: [
+                    {
+                        name: "search_text",
+                        opclass: "gin_trgm_ops"
+                    }
+                ]
+            }
+        ],
+        subsets: {
+            A: [
+                "id",
+                "title",
+                "tags",
+                "aliases",
+                "search_text"
+            ]
+        },
+        enums: {}
+    };
+}
+describe("EntityJsonSchema searchText/opclass validation", ()=>{
+    test("opclass known/free string과 vectorOps 하위호환을 허용해야 한다", ()=>{
+        const knownOpclass = createBaseEntity();
+        const knownResult = EntityJsonSchema.safeParse(knownOpclass);
+        expect(knownResult.success).toBe(true);
+        const freeOpclass = createBaseEntity();
+        freeOpclass.indexes[0] = {
+            ...freeOpclass.indexes[0],
+            columns: [
+                {
+                    name: "search_text",
+                    opclass: "custom_text_ops"
+                }
+            ]
+        };
+        const freeResult = EntityJsonSchema.safeParse(freeOpclass);
+        expect(freeResult.success).toBe(true);
+        const legacyVectorOps = createBaseEntity();
+        legacyVectorOps.indexes[0] = {
+            type: "hnsw",
+            name: "search_text_tests_embedding_hnsw",
+            columns: [
+                {
+                    name: "embedding",
+                    vectorOps: "vector_cosine_ops"
+                }
+            ],
+            m: 16,
+            efConstruction: 64
+        };
+        const legacyResult = EntityJsonSchema.safeParse(legacyVectorOps);
+        expect(legacyResult.success).toBe(true);
+    });
+    test("searchText source column 존재/타입 검증이 동작해야 한다", ()=>{
+        const unknownSource = createBaseEntity();
+        unknownSource.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "missing_col",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const unknownResult = EntityJsonSchema.safeParse(unknownSource);
+        expect(unknownResult.success).toBe(false);
+        const unsupportedSourceType = createBaseEntity();
+        unsupportedSourceType.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "id",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const unsupportedResult = EntityJsonSchema.safeParse(unsupportedSourceType);
+        expect(unsupportedResult.success).toBe(false);
+    });
+    test("schema 단계에서는 searchText json source id naming을 강제하지 않아야 한다", ()=>{
+        const nullableWrapper = createBaseEntity();
+        nullableWrapper.props[3] = {
+            name: "aliases",
+            type: "json",
+            id: "NullableStringArray"
+        };
+        nullableWrapper.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "aliases",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const wrapperResult = EntityJsonSchema.safeParse(nullableWrapper);
+        expect(wrapperResult.success).toBe(true);
+        const nullableElement = createBaseEntity();
+        nullableElement.props[3] = {
+            name: "aliases",
+            type: "json",
+            id: "StringNullableArray"
+        };
+        nullableElement.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "aliases",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const nullableElementResult = EntityJsonSchema.safeParse(nullableElement);
+        expect(nullableElementResult.success).toBe(true);
+        const customNamedType = createBaseEntity();
+        customNamedType.props[3] = {
+            name: "aliases",
+            type: "json",
+            id: "CustomAliasType"
+        };
+        customNamedType.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "aliases",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const customNamedTypeResult = EntityJsonSchema.safeParse(customNamedType);
+        expect(customNamedTypeResult.success).toBe(true);
+    });
+    test("TemplateOptions.entity 경로도 searchText source 검증을 동일하게 적용해야 한다", ()=>{
+        const validEntity = createBaseEntity();
+        const validTemplateEntity = {
+            entityId: validEntity.id,
+            title: validEntity.title,
+            table: validEntity.table,
+            props: validEntity.props,
+            indexes: validEntity.indexes,
+            subsets: validEntity.subsets,
+            enums: validEntity.enums
+        };
+        const validResult = TemplateOptions.shape.entity.safeParse(validTemplateEntity);
+        expect(validResult.success).toBe(true);
+        const invalidEntity = createBaseEntity();
+        invalidEntity.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "missing_col",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const invalidTemplateEntity = {
+            entityId: invalidEntity.id,
+            title: invalidEntity.title,
+            table: invalidEntity.table,
+            props: invalidEntity.props,
+            indexes: invalidEntity.indexes,
+            subsets: invalidEntity.subsets,
+            enums: invalidEntity.enums
+        };
+        const invalidResult = TemplateOptions.shape.entity.safeParse(invalidTemplateEntity);
+        expect(invalidResult.success).toBe(false);
+    });
+    test("TemplateOptions.entity 경로도 json id naming에 의존하지 않아야 한다", ()=>{
+        const customNamedType = createBaseEntity();
+        customNamedType.props[3] = {
+            name: "aliases",
+            type: "json",
+            id: "CustomAliasType"
+        };
+        customNamedType.props[4] = {
+            name: "search_text",
+            type: "searchText",
+            sourceColumns: [
+                {
+                    name: "aliases",
+                    caseInsensitive: true
+                }
+            ]
+        };
+        const customTemplateEntity = {
+            entityId: customNamedType.id,
+            title: customNamedType.title,
+            table: customNamedType.table,
+            props: customNamedType.props,
+            indexes: customNamedType.indexes,
+            subsets: customNamedType.subsets,
+            enums: customNamedType.enums
+        };
+        const customTemplateResult = TemplateOptions.shape.entity.safeParse(customTemplateEntity);
+        expect(customTemplateResult.success).toBe(true);
+    });
+    test("searchText json source Zod 구조 검증 유틸이 wrapper/element 타입을 정확히 판정해야 한다", ()=>{
+        expect(isSearchTextJsonSourceZodType(z.array(z.string()))).toBe(true);
+        expect(isSearchTextJsonSourceZodType(z.array(z.string()).optional())).toBe(true);
+        expect(isSearchTextJsonSourceZodType(z.array(z.string()).nullable())).toBe(true);
+        expect(isSearchTextJsonSourceZodType(z.array(z.string()).nullish())).toBe(true);
+        expect(isSearchTextJsonSourceZodType(z.array(z.string().nullable()))).toBe(false);
+        expect(isSearchTextJsonSourceZodType(z.array(z.number()))).toBe(false);
+        expect(isSearchTextJsonSourceZodType(z.string())).toBe(false);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/types/__tests__/entity-json-schema-search-text.test.ts"],"sourcesContent":["import { describe, expect, test } from \"vitest\";\nimport { z } from \"zod\";\nimport { EntityJsonSchema, isSearchTextJsonSourceZodType, TemplateOptions } from \"../types\";\n\nfunction createBaseEntity() {\n  return {\n    id: \"SearchTextTest\",\n    title: \"SearchText Test\",\n    table: \"search_text_tests\",\n    props: [\n      { name: \"id\", type: \"integer\" },\n      { name: \"title\", type: \"string\" },\n      { name: \"tags\", type: \"string[]\" },\n      { name: \"aliases\", type: \"json\", id: \"StringArray\" },\n      {\n        name: \"search_text\",\n        type: \"searchText\",\n        sourceColumns: [{ name: \"title\", caseInsensitive: true }],\n      },\n    ],\n    indexes: [\n      {\n        type: \"index\",\n        name: \"search_text_tests_search_text_index\",\n        using: \"gin\",\n        columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n      },\n    ],\n    subsets: {\n      A: [\"id\", \"title\", \"tags\", \"aliases\", \"search_text\"],\n    },\n    enums: {},\n  } as const;\n}\n\ndescribe(\"EntityJsonSchema searchText/opclass validation\", () => {\n  test(\"opclass known/free string과 vectorOps 하위호환을 허용해야 한다\", () => {\n    const knownOpclass = createBaseEntity();\n    const knownResult = EntityJsonSchema.safeParse(knownOpclass);\n    expect(knownResult.success).toBe(true);\n\n    const freeOpclass = createBaseEntity();\n    freeOpclass.indexes[0] = {\n      ...freeOpclass.indexes[0],\n      columns: [{ name: \"search_text\", opclass: \"custom_text_ops\" }],\n    };\n    const freeResult = EntityJsonSchema.safeParse(freeOpclass);\n    expect(freeResult.success).toBe(true);\n\n    const legacyVectorOps = createBaseEntity();\n    legacyVectorOps.indexes[0] = {\n      type: \"hnsw\",\n      name: \"search_text_tests_embedding_hnsw\",\n      columns: [{ name: \"embedding\", vectorOps: \"vector_cosine_ops\" }],\n      m: 16,\n      efConstruction: 64,\n    };\n    const legacyResult = EntityJsonSchema.safeParse(legacyVectorOps);\n    expect(legacyResult.success).toBe(true);\n  });\n\n  test(\"searchText source column 존재/타입 검증이 동작해야 한다\", () => {\n    const unknownSource = createBaseEntity();\n    unknownSource.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"missing_col\", caseInsensitive: true }],\n    };\n    const unknownResult = EntityJsonSchema.safeParse(unknownSource);\n    expect(unknownResult.success).toBe(false);\n\n    const unsupportedSourceType = createBaseEntity();\n    unsupportedSourceType.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"id\", caseInsensitive: true }],\n    };\n    const unsupportedResult = EntityJsonSchema.safeParse(unsupportedSourceType);\n    expect(unsupportedResult.success).toBe(false);\n  });\n\n  test(\"schema 단계에서는 searchText json source id naming을 강제하지 않아야 한다\", () => {\n    const nullableWrapper = createBaseEntity();\n    nullableWrapper.props[3] = { name: \"aliases\", type: \"json\", id: \"NullableStringArray\" };\n    nullableWrapper.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"aliases\", caseInsensitive: true }],\n    };\n    const wrapperResult = EntityJsonSchema.safeParse(nullableWrapper);\n    expect(wrapperResult.success).toBe(true);\n\n    const nullableElement = createBaseEntity();\n    nullableElement.props[3] = { name: \"aliases\", type: \"json\", id: \"StringNullableArray\" };\n    nullableElement.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"aliases\", caseInsensitive: true }],\n    };\n    const nullableElementResult = EntityJsonSchema.safeParse(nullableElement);\n    expect(nullableElementResult.success).toBe(true);\n\n    const customNamedType = createBaseEntity();\n    customNamedType.props[3] = { name: \"aliases\", type: \"json\", id: \"CustomAliasType\" };\n    customNamedType.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"aliases\", caseInsensitive: true }],\n    };\n    const customNamedTypeResult = EntityJsonSchema.safeParse(customNamedType);\n    expect(customNamedTypeResult.success).toBe(true);\n  });\n\n  test(\"TemplateOptions.entity 경로도 searchText source 검증을 동일하게 적용해야 한다\", () => {\n    const validEntity = createBaseEntity();\n    const validTemplateEntity = {\n      entityId: validEntity.id,\n      title: validEntity.title,\n      table: validEntity.table,\n      props: validEntity.props,\n      indexes: validEntity.indexes,\n      subsets: validEntity.subsets,\n      enums: validEntity.enums,\n    };\n    const validResult = TemplateOptions.shape.entity.safeParse(validTemplateEntity);\n    expect(validResult.success).toBe(true);\n\n    const invalidEntity = createBaseEntity();\n    invalidEntity.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"missing_col\", caseInsensitive: true }],\n    };\n    const invalidTemplateEntity = {\n      entityId: invalidEntity.id,\n      title: invalidEntity.title,\n      table: invalidEntity.table,\n      props: invalidEntity.props,\n      indexes: invalidEntity.indexes,\n      subsets: invalidEntity.subsets,\n      enums: invalidEntity.enums,\n    };\n    const invalidResult = TemplateOptions.shape.entity.safeParse(invalidTemplateEntity);\n    expect(invalidResult.success).toBe(false);\n  });\n\n  test(\"TemplateOptions.entity 경로도 json id naming에 의존하지 않아야 한다\", () => {\n    const customNamedType = createBaseEntity();\n    customNamedType.props[3] = { name: \"aliases\", type: \"json\", id: \"CustomAliasType\" };\n    customNamedType.props[4] = {\n      name: \"search_text\",\n      type: \"searchText\",\n      sourceColumns: [{ name: \"aliases\", caseInsensitive: true }],\n    };\n\n    const customTemplateEntity = {\n      entityId: customNamedType.id,\n      title: customNamedType.title,\n      table: customNamedType.table,\n      props: customNamedType.props,\n      indexes: customNamedType.indexes,\n      subsets: customNamedType.subsets,\n      enums: customNamedType.enums,\n    };\n    const customTemplateResult = TemplateOptions.shape.entity.safeParse(customTemplateEntity);\n    expect(customTemplateResult.success).toBe(true);\n  });\n\n  test(\"searchText json source Zod 구조 검증 유틸이 wrapper/element 타입을 정확히 판정해야 한다\", () => {\n    expect(isSearchTextJsonSourceZodType(z.array(z.string()))).toBe(true);\n    expect(isSearchTextJsonSourceZodType(z.array(z.string()).optional())).toBe(true);\n    expect(isSearchTextJsonSourceZodType(z.array(z.string()).nullable())).toBe(true);\n    expect(isSearchTextJsonSourceZodType(z.array(z.string()).nullish())).toBe(true);\n\n    expect(isSearchTextJsonSourceZodType(z.array(z.string().nullable()))).toBe(false);\n    expect(isSearchTextJsonSourceZodType(z.array(z.number()))).toBe(false);\n    expect(isSearchTextJsonSourceZodType(z.string())).toBe(false);\n  });\n});\n"],"names":["describe","expect","test","z","EntityJsonSchema","isSearchTextJsonSourceZodType","TemplateOptions","createBaseEntity","id","title","table","props","name","type","sourceColumns","caseInsensitive","indexes","using","columns","opclass","subsets","A","enums","knownOpclass","knownResult","safeParse","success","toBe","freeOpclass","freeResult","legacyVectorOps","vectorOps","m","efConstruction","legacyResult","unknownSource","unknownResult","unsupportedSourceType","unsupportedResult","nullableWrapper","wrapperResult","nullableElement","nullableElementResult","customNamedType","customNamedTypeResult","validEntity","validTemplateEntity","entityId","validResult","shape","entity","invalidEntity","invalidTemplateEntity","invalidResult","customTemplateEntity","customTemplateResult","array","string","optional","nullable","nullish","number"],"mappings":"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"}