sonamu 0.8.13 → 0.8.14

package/dist/migration/__tests__/code-generation.search-text.test.js

@@ -0,0 +1,435 @@
+import { describe, expect, test } from "vitest";
+import { Sonamu } from "../../api/index.js";
+import { Entity } from "../../entity/entity.js";
+import { EntityManager } from "../../entity/entity-manager.js";
+import { setupBiome } from "../../utils/formatter.js";
+import { generateAlterCode, generateCreateCode, setMigrationIndexDefaults } from "../code-generation.js";
+import { getMigrationSetFromEntity } from "../migration-set.js";
+const TEST_API_ROOT = "/Users/Nebuleto/Workspace/sonamu/modules/sonamu";
+setupBiome(TEST_API_ROOT);
+Sonamu.apiRootPath = TEST_API_ROOT;
+let entitySeq = 0;
+async function registerEntity(definition) {
+    entitySeq += 1;
+    const entity = {
+        ...definition,
+        id: `${definition.id}${entitySeq}`,
+        title: `${definition.id}${entitySeq}`,
+        table: `${definition.table}_${entitySeq}`,
+        subsets: {
+            A: definition.props.map((prop)=>prop.name)
+        },
+        enums: {}
+    };
+    await EntityManager.register(entity, {
+        deferSearchTextJsonSourceValidation: true
+    });
+    return EntityManager.get(entity.id);
+}
+function buildDbSetWithGeneratedSearchText(entitySet, expression) {
+    return {
+        ...entitySet,
+        columns: entitySet.columns.map((column)=>column.name === "search_text" ? {
+                ...column,
+                generated: {
+                    type: "STORED",
+                    expression
+                }
+            } : column)
+    };
+}
+describe("code-generation searchText/opclass DDL", ()=>{
+    test("searchText가 없으면 generated/helper SQL을 추가하지 않고 vector index를 유지해야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationNoSearchText",
+            table: "code_generation_no_search_text",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "title",
+                    type: "string"
+                },
+                {
+                    name: "embedding",
+                    type: "vector",
+                    dimensions: 1536
+                }
+            ],
+            indexes: [
+                {
+                    type: "hnsw",
+                    name: "code_generation_no_search_text_embedding_hnsw",
+                    columns: [
+                        {
+                            name: "embedding",
+                            vectorOps: "vector_cosine_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const [migration] = await generateCreateCode(getMigrationSetFromEntity(entity));
+        expect(migration.formatted).not.toContain("GENERATED ALWAYS AS");
+        expect(migration.formatted).not.toContain("sonamu_text_array_agg");
+        expect(migration.formatted).not.toContain("sonamu_jsonb_array_agg");
+        expect(migration.formatted).toContain("USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64)");
+    });
+    test("searchText generated DDL, helper 함수, generic opclass를 올바르게 출력해야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationSearchText",
+            table: "code_generation_search_text",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "title_ci",
+                    type: "string"
+                },
+                {
+                    name: "code_cs",
+                    type: "string"
+                },
+                {
+                    name: "tags_ci",
+                    type: "string[]"
+                },
+                {
+                    name: "tags_cs",
+                    type: "string[]"
+                },
+                {
+                    name: "aliases_ci",
+                    type: "json",
+                    id: "StringArrayCi"
+                },
+                {
+                    name: "aliases_cs",
+                    type: "json",
+                    id: "StringArrayCs"
+                },
+                {
+                    name: "search_text",
+                    type: "searchText",
+                    sourceColumns: [
+                        {
+                            name: "title_ci",
+                            caseInsensitive: true
+                        },
+                        {
+                            name: "code_cs",
+                            caseInsensitive: false
+                        },
+                        {
+                            name: "tags_ci",
+                            caseInsensitive: true
+                        },
+                        {
+                            name: "tags_cs",
+                            caseInsensitive: false
+                        },
+                        {
+                            name: "aliases_ci",
+                            caseInsensitive: true
+                        },
+                        {
+                            name: "aliases_cs",
+                            caseInsensitive: false
+                        }
+                    ]
+                }
+            ],
+            indexes: [
+                {
+                    type: "index",
+                    name: "code_generation_search_text_search_text_index",
+                    using: "gin",
+                    columns: [
+                        {
+                            name: "search_text",
+                            opclass: "gin_trgm_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const [migration] = await generateCreateCode(getMigrationSetFromEntity(entity));
+        expect(migration.formatted).toContain("CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)");
+        expect(migration.formatted).toContain("CREATE OR REPLACE FUNCTION sonamu_jsonb_array_agg(arr jsonb, ci boolean DEFAULT true)");
+        expect(migration.formatted).toContain("ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(lower(COALESCE(title_ci, '')) || ' ' || COALESCE(code_cs, '')");
+        expect(migration.formatted).toContain("COALESCE(sonamu_text_array_agg(tags_ci), '')");
+        expect(migration.formatted).toContain("COALESCE(sonamu_text_array_agg(tags_cs, false), '')");
+        expect(migration.formatted).toContain("COALESCE(sonamu_jsonb_array_agg(aliases_ci), '')");
+        expect(migration.formatted).toContain("COALESCE(sonamu_jsonb_array_agg(aliases_cs, false), '')");
+        expect(migration.formatted).toContain("CREATE INDEX code_generation_search_text_search_text_index ON");
+        expect(migration.formatted).toContain("USING gin(search_text gin_trgm_ops);");
+    });
+    test("searchText generated expression 변경 시 alter path에서 helper와 index를 함께 재생성해야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationSearchTextAlter",
+            table: "code_generation_search_text_alter",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "title_ci",
+                    type: "string"
+                },
+                {
+                    name: "tags_ci",
+                    type: "string[]"
+                },
+                {
+                    name: "search_text",
+                    type: "searchText",
+                    sourceColumns: [
+                        {
+                            name: "title_ci",
+                            caseInsensitive: false
+                        },
+                        {
+                            name: "tags_ci",
+                            caseInsensitive: true
+                        }
+                    ]
+                }
+            ],
+            indexes: [
+                {
+                    type: "index",
+                    name: "code_generation_search_text_alter_search_text_index",
+                    using: "gin",
+                    columns: [
+                        {
+                            name: "search_text",
+                            opclass: "gin_trgm_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const entitySet = getMigrationSetFromEntity(entity);
+        const dbSet = buildDbSetWithGeneratedSearchText(entitySet, `trim(lower(COALESCE(title_ci, '')))`);
+        const [migration] = await generateAlterCode(entitySet, dbSet);
+        expect(migration.formatted).toContain('table.dropIndex(["search_text"], "code_generation_search_text_alter_search_text_index")');
+        expect(migration.formatted).toContain('table.dropColumns("search_text")');
+        expect(migration.formatted).toContain("CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)");
+        expect(migration.formatted).toContain(`ADD COLUMN "search_text" text GENERATED ALWAYS AS (trim(COALESCE(title_ci, '') || ' ' || COALESCE(sonamu_text_array_agg(tags_ci), ''))) STORED NOT NULL`);
+        expect(migration.formatted).toContain("CREATE INDEX code_generation_search_text_alter_search_text_index ON");
+        expect(migration.formatted).toContain(`ADD COLUMN "search_text" text GENERATED ALWAYS AS (trim(lower(COALESCE(title_ci, '')))) STORED NOT NULL`);
+    });
+    test("searchText generated expression이 Postgres canonical form과 semantically equivalent면 no-op이어야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationSearchTextCanonicalNoop",
+            table: "code_generation_search_text_canonical_noop",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "username",
+                    type: "string"
+                },
+                {
+                    name: "tags",
+                    type: "string[]"
+                },
+                {
+                    name: "search_text",
+                    type: "searchText",
+                    sourceColumns: [
+                        {
+                            name: "username",
+                            caseInsensitive: false
+                        },
+                        {
+                            name: "tags",
+                            caseInsensitive: true
+                        }
+                    ]
+                }
+            ],
+            indexes: [
+                {
+                    type: "index",
+                    name: "code_generation_search_text_canonical_noop_search_text_index",
+                    using: "gin",
+                    columns: [
+                        {
+                            name: "search_text",
+                            opclass: "gin_trgm_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const entitySet = getMigrationSetFromEntity(entity);
+        const dbSet = buildDbSetWithGeneratedSearchText({
+            ...entitySet,
+            indexes: entitySet.indexes.map(setMigrationIndexDefaults)
+        }, `TRIM(BOTH FROM ((COALESCE(username, ''::text)) || ' '::text) || COALESCE(sonamu_text_array_agg(tags, true), ''::text))`);
+        const migrations = await generateAlterCode(entitySet, dbSet);
+        expect(migrations).toHaveLength(0);
+    });
+    test("searchText caseInsensitive 변경만 있어도 alter path에서 재생성해야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationSearchTextCaseInsensitiveAlter",
+            table: "code_generation_search_text_case_insensitive_alter",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "title_ci",
+                    type: "string"
+                },
+                {
+                    name: "search_text",
+                    type: "searchText",
+                    sourceColumns: [
+                        {
+                            name: "title_ci",
+                            caseInsensitive: false
+                        }
+                    ]
+                }
+            ],
+            indexes: [
+                {
+                    type: "index",
+                    name: "code_generation_search_text_case_insensitive_alter_search_text_index",
+                    using: "gin",
+                    columns: [
+                        {
+                            name: "search_text",
+                            opclass: "gin_trgm_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const entitySet = getMigrationSetFromEntity(entity);
+        const dbSet = buildDbSetWithGeneratedSearchText(entitySet, `TRIM(BOTH FROM lower(COALESCE(title_ci, ''::text)))`);
+        const [migration] = await generateAlterCode(entitySet, dbSet);
+        expect(migration.formatted).toContain("table.dropIndex(");
+        expect(migration.formatted).toContain('"code_generation_search_text_case_insensitive_alter_search_text_index"');
+        expect(migration.formatted).toContain('table.dropColumns("search_text")');
+        expect(migration.formatted).toContain(`ADD COLUMN "search_text" text GENERATED ALWAYS AS (trim(COALESCE(title_ci, ''))) STORED NOT NULL`);
+        expect(migration.formatted).toContain("lower(COALESCE(title_ci");
+    });
+    test("searchText helper kind가 바뀌어도 down path는 복원 expression 기준 helper를 재생성해야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationSearchTextRollbackHelperMismatch",
+            table: "code_generation_search_text_rollback_helper_mismatch",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "tags",
+                    type: "string[]"
+                },
+                {
+                    name: "aliases",
+                    type: "json",
+                    id: "RollbackHelperMismatchJson"
+                },
+                {
+                    name: "search_text",
+                    type: "searchText",
+                    sourceColumns: [
+                        {
+                            name: "tags",
+                            caseInsensitive: true
+                        }
+                    ]
+                }
+            ],
+            indexes: [
+                {
+                    type: "index",
+                    name: "code_generation_search_text_rollback_helper_mismatch_search_text_index",
+                    using: "gin",
+                    columns: [
+                        {
+                            name: "search_text",
+                            opclass: "gin_trgm_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const entitySet = getMigrationSetFromEntity(entity);
+        const dbSet = buildDbSetWithGeneratedSearchText(entitySet, `trim(COALESCE(sonamu_jsonb_array_agg(aliases), ''))`);
+        const [migration] = await generateAlterCode(entitySet, dbSet);
+        expect(migration.formatted).toContain("CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)");
+        expect(migration.formatted).toContain(`ADD COLUMN "search_text" text GENERATED ALWAYS AS (trim(COALESCE(sonamu_text_array_agg(tags), ''))) STORED NOT NULL`);
+        expect(migration.formatted).toContain("CREATE OR REPLACE FUNCTION sonamu_jsonb_array_agg(arr jsonb, ci boolean DEFAULT true)");
+        expect(migration.formatted).toContain(`ADD COLUMN "search_text" text GENERATED ALWAYS AS (trim(COALESCE(sonamu_jsonb_array_agg(aliases), ''))) STORED NOT NULL`);
+    });
+    test("searchText가 제거되어도 down path는 이전 expression helper를 복원해야 한다", async ()=>{
+        const entity = await registerEntity({
+            id: "CodeGenerationSearchTextRollbackDropped",
+            table: "code_generation_search_text_rollback_dropped",
+            props: [
+                {
+                    name: "id",
+                    type: "integer"
+                },
+                {
+                    name: "tags",
+                    type: "string[]"
+                }
+            ],
+            indexes: []
+        });
+        const previousEntity = new Entity({
+            ...entity.toJson(),
+            props: [
+                ...entity.toJson().props,
+                {
+                    name: "search_text",
+                    type: "searchText",
+                    sourceColumns: [
+                        {
+                            name: "tags",
+                            caseInsensitive: true
+                        }
+                    ]
+                }
+            ],
+            indexes: [
+                {
+                    type: "index",
+                    name: "code_generation_search_text_rollback_dropped_search_text_index",
+                    using: "gin",
+                    columns: [
+                        {
+                            name: "search_text",
+                            opclass: "gin_trgm_ops"
+                        }
+                    ]
+                }
+            ]
+        });
+        const entitySet = getMigrationSetFromEntity(entity);
+        const dbSet = buildDbSetWithGeneratedSearchText(getMigrationSetFromEntity(previousEntity), `trim(COALESCE(sonamu_text_array_agg(tags), ''))`);
+        const [migration] = await generateAlterCode(entitySet, dbSet);
+        expect(migration.formatted).toContain('table.dropColumns("search_text")');
+        expect(migration.formatted).toContain("CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)");
+        expect(migration.formatted).toContain(`ADD COLUMN "search_text" text GENERATED ALWAYS AS (trim(COALESCE(sonamu_text_array_agg(tags), ''))) STORED NOT NULL`);
+        expect(migration.formatted).toContain("CREATE INDEX code_generation_search_text_rollback_dropped_search_text_index ON");
+        expect(migration.formatted).toContain("USING gin(search_text gin_trgm_ops);");
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/migration/__tests__/code-generation.search-text.test.ts"],"sourcesContent":["import { describe, expect, test } from \"vitest\";\nimport { Sonamu } from \"../../api\";\nimport { Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport type { MigrationSet } from \"../../types/types\";\nimport { setupBiome } from \"../../utils/formatter\";\nimport {\n  generateAlterCode,\n  generateCreateCode,\n  setMigrationIndexDefaults,\n} from \"../code-generation\";\nimport { getMigrationSetFromEntity } from \"../migration-set\";\n\nconst TEST_API_ROOT = \"/Users/Nebuleto/Workspace/sonamu/modules/sonamu\";\n\nsetupBiome(TEST_API_ROOT);\nSonamu.apiRootPath = TEST_API_ROOT;\n\nlet entitySeq = 0;\n\nasync function registerEntity(\n  definition: Omit<\n    Parameters<typeof EntityManager.register>[0],\n    \"id\" | \"table\" | \"title\" | \"subsets\" | \"enums\"\n  > & {\n    id: string;\n    table: string;\n  },\n) {\n  entitySeq += 1;\n\n  const entity = {\n    ...definition,\n    id: `${definition.id}${entitySeq}`,\n    title: `${definition.id}${entitySeq}`,\n    table: `${definition.table}_${entitySeq}`,\n    subsets: {\n      A: definition.props.map((prop) => prop.name),\n    },\n    enums: {},\n  };\n\n  await EntityManager.register(entity, {\n    deferSearchTextJsonSourceValidation: true,\n  });\n\n  return EntityManager.get(entity.id);\n}\n\nfunction buildDbSetWithGeneratedSearchText(\n  entitySet: MigrationSet,\n  expression: string,\n): MigrationSet {\n  return {\n    ...entitySet,\n    columns: entitySet.columns.map((column) =>\n      column.name === \"search_text\"\n        ? {\n            ...column,\n            generated: {\n              type: \"STORED\",\n              expression,\n            },\n          }\n        : column,\n    ),\n  };\n}\n\ndescribe(\"code-generation searchText/opclass DDL\", () => {\n  test(\"searchText가 없으면 generated/helper SQL을 추가하지 않고 vector index를 유지해야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationNoSearchText\",\n      table: \"code_generation_no_search_text\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"title\", type: \"string\" },\n        { name: \"embedding\", type: \"vector\", dimensions: 1536 },\n      ],\n      indexes: [\n        {\n          type: \"hnsw\",\n          name: \"code_generation_no_search_text_embedding_hnsw\",\n          columns: [{ name: \"embedding\", vectorOps: \"vector_cosine_ops\" }],\n        },\n      ],\n    });\n\n    const [migration] = await generateCreateCode(getMigrationSetFromEntity(entity));\n\n    expect(migration.formatted).not.toContain(\"GENERATED ALWAYS AS\");\n    expect(migration.formatted).not.toContain(\"sonamu_text_array_agg\");\n    expect(migration.formatted).not.toContain(\"sonamu_jsonb_array_agg\");\n    expect(migration.formatted).toContain(\n      \"USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64)\",\n    );\n  });\n\n  test(\"searchText generated DDL, helper 함수, generic opclass를 올바르게 출력해야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationSearchText\",\n      table: \"code_generation_search_text\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"title_ci\", type: \"string\" },\n        { name: \"code_cs\", type: \"string\" },\n        { name: \"tags_ci\", type: \"string[]\" },\n        { name: \"tags_cs\", type: \"string[]\" },\n        { name: \"aliases_ci\", type: \"json\", id: \"StringArrayCi\" },\n        { name: \"aliases_cs\", type: \"json\", id: \"StringArrayCs\" },\n        {\n          name: \"search_text\",\n          type: \"searchText\",\n          sourceColumns: [\n            { name: \"title_ci\", caseInsensitive: true },\n            { name: \"code_cs\", caseInsensitive: false },\n            { name: \"tags_ci\", caseInsensitive: true },\n            { name: \"tags_cs\", caseInsensitive: false },\n            { name: \"aliases_ci\", caseInsensitive: true },\n            { name: \"aliases_cs\", caseInsensitive: false },\n          ],\n        },\n      ],\n      indexes: [\n        {\n          type: \"index\",\n          name: \"code_generation_search_text_search_text_index\",\n          using: \"gin\",\n          columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n        },\n      ],\n    });\n\n    const [migration] = await generateCreateCode(getMigrationSetFromEntity(entity));\n\n    expect(migration.formatted).toContain(\n      \"CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)\",\n    );\n    expect(migration.formatted).toContain(\n      \"CREATE OR REPLACE FUNCTION sonamu_jsonb_array_agg(arr jsonb, ci boolean DEFAULT true)\",\n    );\n    expect(migration.formatted).toContain(\n      \"ADD COLUMN \\\"search_text\\\" text GENERATED ALWAYS AS (trim(lower(COALESCE(title_ci, '')) || ' ' || COALESCE(code_cs, '')\",\n    );\n    expect(migration.formatted).toContain(\"COALESCE(sonamu_text_array_agg(tags_ci), '')\");\n    expect(migration.formatted).toContain(\"COALESCE(sonamu_text_array_agg(tags_cs, false), '')\");\n    expect(migration.formatted).toContain(\"COALESCE(sonamu_jsonb_array_agg(aliases_ci), '')\");\n    expect(migration.formatted).toContain(\n      \"COALESCE(sonamu_jsonb_array_agg(aliases_cs, false), '')\",\n    );\n    expect(migration.formatted).toContain(\n      \"CREATE INDEX code_generation_search_text_search_text_index ON\",\n    );\n    expect(migration.formatted).toContain(\"USING gin(search_text gin_trgm_ops);\");\n  });\n\n  test(\"searchText generated expression 변경 시 alter path에서 helper와 index를 함께 재생성해야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationSearchTextAlter\",\n      table: \"code_generation_search_text_alter\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"title_ci\", type: \"string\" },\n        { name: \"tags_ci\", type: \"string[]\" },\n        {\n          name: \"search_text\",\n          type: \"searchText\",\n          sourceColumns: [\n            { name: \"title_ci\", caseInsensitive: false },\n            { name: \"tags_ci\", caseInsensitive: true },\n          ],\n        },\n      ],\n      indexes: [\n        {\n          type: \"index\",\n          name: \"code_generation_search_text_alter_search_text_index\",\n          using: \"gin\",\n          columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n        },\n      ],\n    });\n\n    const entitySet = getMigrationSetFromEntity(entity);\n    const dbSet = buildDbSetWithGeneratedSearchText(\n      entitySet,\n      `trim(lower(COALESCE(title_ci, '')))`,\n    );\n\n    const [migration] = await generateAlterCode(entitySet, dbSet);\n\n    expect(migration.formatted).toContain(\n      'table.dropIndex([\"search_text\"], \"code_generation_search_text_alter_search_text_index\")',\n    );\n    expect(migration.formatted).toContain('table.dropColumns(\"search_text\")');\n    expect(migration.formatted).toContain(\n      \"CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)\",\n    );\n    expect(migration.formatted).toContain(\n      `ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(COALESCE(title_ci, '') || ' ' || COALESCE(sonamu_text_array_agg(tags_ci), ''))) STORED NOT NULL`,\n    );\n    expect(migration.formatted).toContain(\n      \"CREATE INDEX code_generation_search_text_alter_search_text_index ON\",\n    );\n    expect(migration.formatted).toContain(\n      `ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(lower(COALESCE(title_ci, '')))) STORED NOT NULL`,\n    );\n  });\n\n  test(\"searchText generated expression이 Postgres canonical form과 semantically equivalent면 no-op이어야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationSearchTextCanonicalNoop\",\n      table: \"code_generation_search_text_canonical_noop\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"username\", type: \"string\" },\n        { name: \"tags\", type: \"string[]\" },\n        {\n          name: \"search_text\",\n          type: \"searchText\",\n          sourceColumns: [\n            { name: \"username\", caseInsensitive: false },\n            { name: \"tags\", caseInsensitive: true },\n          ],\n        },\n      ],\n      indexes: [\n        {\n          type: \"index\",\n          name: \"code_generation_search_text_canonical_noop_search_text_index\",\n          using: \"gin\",\n          columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n        },\n      ],\n    });\n\n    const entitySet = getMigrationSetFromEntity(entity);\n    const dbSet = buildDbSetWithGeneratedSearchText(\n      {\n        ...entitySet,\n        indexes: entitySet.indexes.map(setMigrationIndexDefaults),\n      },\n      `TRIM(BOTH FROM ((COALESCE(username, ''::text)) || ' '::text) || COALESCE(sonamu_text_array_agg(tags, true), ''::text))`,\n    );\n\n    const migrations = await generateAlterCode(entitySet, dbSet);\n\n    expect(migrations).toHaveLength(0);\n  });\n\n  test(\"searchText caseInsensitive 변경만 있어도 alter path에서 재생성해야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationSearchTextCaseInsensitiveAlter\",\n      table: \"code_generation_search_text_case_insensitive_alter\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"title_ci\", type: \"string\" },\n        {\n          name: \"search_text\",\n          type: \"searchText\",\n          sourceColumns: [{ name: \"title_ci\", caseInsensitive: false }],\n        },\n      ],\n      indexes: [\n        {\n          type: \"index\",\n          name: \"code_generation_search_text_case_insensitive_alter_search_text_index\",\n          using: \"gin\",\n          columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n        },\n      ],\n    });\n\n    const entitySet = getMigrationSetFromEntity(entity);\n    const dbSet = buildDbSetWithGeneratedSearchText(\n      entitySet,\n      `TRIM(BOTH FROM lower(COALESCE(title_ci, ''::text)))`,\n    );\n\n    const [migration] = await generateAlterCode(entitySet, dbSet);\n\n    expect(migration.formatted).toContain(\"table.dropIndex(\");\n    expect(migration.formatted).toContain(\n      '\"code_generation_search_text_case_insensitive_alter_search_text_index\"',\n    );\n    expect(migration.formatted).toContain('table.dropColumns(\"search_text\")');\n    expect(migration.formatted).toContain(\n      `ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(COALESCE(title_ci, ''))) STORED NOT NULL`,\n    );\n    expect(migration.formatted).toContain(\"lower(COALESCE(title_ci\");\n  });\n\n  test(\"searchText helper kind가 바뀌어도 down path는 복원 expression 기준 helper를 재생성해야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationSearchTextRollbackHelperMismatch\",\n      table: \"code_generation_search_text_rollback_helper_mismatch\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"tags\", type: \"string[]\" },\n        { name: \"aliases\", type: \"json\", id: \"RollbackHelperMismatchJson\" },\n        {\n          name: \"search_text\",\n          type: \"searchText\",\n          sourceColumns: [{ name: \"tags\", caseInsensitive: true }],\n        },\n      ],\n      indexes: [\n        {\n          type: \"index\",\n          name: \"code_generation_search_text_rollback_helper_mismatch_search_text_index\",\n          using: \"gin\",\n          columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n        },\n      ],\n    });\n\n    const entitySet = getMigrationSetFromEntity(entity);\n    const dbSet = buildDbSetWithGeneratedSearchText(\n      entitySet,\n      `trim(COALESCE(sonamu_jsonb_array_agg(aliases), ''))`,\n    );\n\n    const [migration] = await generateAlterCode(entitySet, dbSet);\n\n    expect(migration.formatted).toContain(\n      \"CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)\",\n    );\n    expect(migration.formatted).toContain(\n      `ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(COALESCE(sonamu_text_array_agg(tags), ''))) STORED NOT NULL`,\n    );\n    expect(migration.formatted).toContain(\n      \"CREATE OR REPLACE FUNCTION sonamu_jsonb_array_agg(arr jsonb, ci boolean DEFAULT true)\",\n    );\n    expect(migration.formatted).toContain(\n      `ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(COALESCE(sonamu_jsonb_array_agg(aliases), ''))) STORED NOT NULL`,\n    );\n  });\n\n  test(\"searchText가 제거되어도 down path는 이전 expression helper를 복원해야 한다\", async () => {\n    const entity = await registerEntity({\n      id: \"CodeGenerationSearchTextRollbackDropped\",\n      table: \"code_generation_search_text_rollback_dropped\",\n      props: [\n        { name: \"id\", type: \"integer\" },\n        { name: \"tags\", type: \"string[]\" },\n      ],\n      indexes: [],\n    });\n\n    const previousEntity = new Entity({\n      ...entity.toJson(),\n      props: [\n        ...entity.toJson().props,\n        {\n          name: \"search_text\",\n          type: \"searchText\",\n          sourceColumns: [{ name: \"tags\", caseInsensitive: true }],\n        },\n      ],\n      indexes: [\n        {\n          type: \"index\",\n          name: \"code_generation_search_text_rollback_dropped_search_text_index\",\n          using: \"gin\",\n          columns: [{ name: \"search_text\", opclass: \"gin_trgm_ops\" }],\n        },\n      ],\n    });\n\n    const entitySet = getMigrationSetFromEntity(entity);\n    const dbSet = buildDbSetWithGeneratedSearchText(\n      getMigrationSetFromEntity(previousEntity),\n      `trim(COALESCE(sonamu_text_array_agg(tags), ''))`,\n    );\n\n    const [migration] = await generateAlterCode(entitySet, dbSet);\n\n    expect(migration.formatted).toContain('table.dropColumns(\"search_text\")');\n    expect(migration.formatted).toContain(\n      \"CREATE OR REPLACE FUNCTION sonamu_text_array_agg(arr text[], ci boolean DEFAULT true)\",\n    );\n    expect(migration.formatted).toContain(\n      `ADD COLUMN \"search_text\" text GENERATED ALWAYS AS (trim(COALESCE(sonamu_text_array_agg(tags), ''))) STORED NOT NULL`,\n    );\n    expect(migration.formatted).toContain(\n      \"CREATE INDEX code_generation_search_text_rollback_dropped_search_text_index ON\",\n    );\n    expect(migration.formatted).toContain(\"USING gin(search_text gin_trgm_ops);\");\n  });\n});\n"],"names":["describe","expect","test","Sonamu","Entity","EntityManager","setupBiome","generateAlterCode","generateCreateCode","setMigrationIndexDefaults","getMigrationSetFromEntity","TEST_API_ROOT","apiRootPath","entitySeq","registerEntity","definition","entity","id","title","table","subsets","A","props","map","prop","name","enums","register","deferSearchTextJsonSourceValidation","get","buildDbSetWithGeneratedSearchText","entitySet","expression","columns","column","generated","type","dimensions","indexes","vectorOps","migration","formatted","not","toContain","sourceColumns","caseInsensitive","using","opclass","dbSet","migrations","toHaveLength","previousEntity","toJson"],"mappings":"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"}

package/dist/migration/code-generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generation.d.ts","sourceRoot":"","sources":["../../src/migration/code-generation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,OAAO,KAAK,EAEV,gBAAgB,EAGhB,cAAc,EACd,YAAY,EACb,MAAM,gBAAgB,CAAC;AA4uBxB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;SAG/E,cAAc,EAAE;UACf,cAAc,EAAE;EAuC/B;AAWD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAoB/E;AAuHD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAS7F;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,IAAI,GACf,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAyG7B"}
+{"version":3,"file":"code-generation.d.ts","sourceRoot":"","sources":["../../src/migration/code-generation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,OAAO,KAAK,EAEV,gBAAgB,EAGhB,cAAc,EACd,YAAY,EACb,MAAM,gBAAgB,CAAC;AAyhDxB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;SAG/E,cAAc,EAAE;UACf,cAAc,EAAE;EAuC/B;AAWD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAoB/E;AAuHD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAS7F;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,IAAI,GACf,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0G7B"}