@gqlkit-ts/cli 0.0.1 → 0.1.0

package/dist/config-loader/validator.test.js

@@ -0,0 +1,846 @@
+import { describe, expect, it } from "vitest";
+import { validateConfig } from "./validator.js";
+describe("ConfigValidator", () => {
+    const configPath = "/project/gqlkit.config.ts";
+    describe("validateConfig", () => {
+        it("should return valid for empty config", () => {
+            const result = validateConfig({
+                config: {},
+                configPath,
+            });
+            expect(result.valid).toBe(true);
+            expect(result.resolvedConfig).toBeTruthy();
+            expect(result.resolvedConfig.scalars).toEqual([]);
+            expect(result.diagnostics.length).toBe(0);
+        });
+        it("should return valid for config with scalars", () => {
+            const result = validateConfig({
+                config: {
+                    scalars: [
+                        {
+                            graphqlName: "DateTime",
+                            type: { from: "./src/scalars", name: "DateTime" },
+                        },
+                    ],
+                },
+                configPath,
+            });
+            expect(result.valid).toBe(true);
+            expect(result.resolvedConfig).toBeTruthy();
+            expect(result.resolvedConfig.scalars.length).toBe(1);
+        });
+        it("should return error for non-object config", () => {
+            const result = validateConfig({
+                config: "not an object",
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+        });
+        it("should return error for null config", () => {
+            const result = validateConfig({
+                config: null,
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+        });
+        it("should return error when scalars is not an array", () => {
+            const result = validateConfig({
+                config: {
+                    scalars: "not an array",
+                },
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+            expect(result.diagnostics[0]?.message).toContain("scalars");
+        });
+        it("should return error when scalar mapping is missing graphqlName", () => {
+            const result = validateConfig({
+                config: {
+                    scalars: [
+                        {
+                            type: { from: "./src/scalars", name: "DateTime" },
+                        },
+                    ],
+                },
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_MISSING_PROPERTY");
+            expect(result.diagnostics[0]?.message).toContain("graphqlName");
+        });
+        it("should return error when scalar mapping is missing type", () => {
+            const result = validateConfig({
+                config: {
+                    scalars: [
+                        {
+                            graphqlName: "DateTime",
+                        },
+                    ],
+                },
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_MISSING_PROPERTY");
+            expect(result.diagnostics[0]?.message).toContain("type");
+        });
+        it("should return error when type.from is missing", () => {
+            const result = validateConfig({
+                config: {
+                    scalars: [
+                        {
+                            graphqlName: "DateTime",
+                            type: { name: "DateTime" },
+                        },
+                    ],
+                },
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_MISSING_PROPERTY");
+            expect(result.diagnostics[0]?.message).toContain("type.from");
+        });
+        it("should return error when type.name is missing", () => {
+            const result = validateConfig({
+                config: {
+                    scalars: [
+                        {
+                            graphqlName: "DateTime",
+                            type: { from: "./src/scalars" },
+                        },
+                    ],
+                },
+                configPath,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.diagnostics.length).toBe(1);
+            expect(result.diagnostics[0]?.code).toBe("CONFIG_MISSING_PROPERTY");
+            expect(result.diagnostics[0]?.message).toContain("type.name");
+        });
+        describe("built-in scalar override", () => {
+            for (const builtinName of ["ID", "String", "Int", "Float", "Boolean"]) {
+                it(`should return error when overriding built-in scalar ${builtinName}`, () => {
+                    const result = validateConfig({
+                        config: {
+                            scalars: [
+                                {
+                                    graphqlName: builtinName,
+                                    type: { from: "./src/scalars", name: "Custom" },
+                                },
+                            ],
+                        },
+                        configPath,
+                    });
+                    expect(result.valid).toBe(false);
+                    expect(result.diagnostics.length).toBe(1);
+                    expect(result.diagnostics[0]?.code).toBe("CONFIG_BUILTIN_OVERRIDE");
+                    expect(result.diagnostics[0]?.message).toContain(builtinName);
+                });
+            }
+        });
+        describe("duplicate detection", () => {
+            it("should return error for duplicate graphqlName", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                graphqlName: "DateTime",
+                                type: { from: "./src/scalars", name: "DateTime" },
+                            },
+                            {
+                                graphqlName: "DateTime",
+                                type: { from: "./src/other", name: "OtherDateTime" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_DUPLICATE_MAPPING");
+                expect(result.diagnostics[0]?.message).toContain("DateTime");
+            });
+            it("should return error for duplicate type mapping", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                graphqlName: "DateTime",
+                                type: { from: "./src/scalars", name: "DateTime" },
+                            },
+                            {
+                                graphqlName: "Timestamp",
+                                type: { from: "./src/scalars", name: "DateTime" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_DUPLICATE_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("DateTime");
+            });
+            it("should allow same type name from different paths", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                graphqlName: "DateTime",
+                                type: { from: "./src/scalars", name: "DateTime" },
+                            },
+                            {
+                                graphqlName: "CustomDateTime",
+                                type: { from: "./src/custom", name: "DateTime" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.diagnostics.length).toBe(0);
+            });
+        });
+        describe("new scalar config format (name, tsType)", () => {
+            it("should accept new format with name and tsType.name", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars.length).toBe(1);
+                expect(result.resolvedConfig.scalars[0]?.graphqlName).toBe("DateTime");
+                expect(result.resolvedConfig.scalars[0]?.typeName).toBe("Date");
+                expect(result.resolvedConfig.scalars[0]?.importPath).toBe(null);
+            });
+            it("should accept new format with tsType.from for module specification", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "DateTimeString", from: "./src/types" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars.length).toBe(1);
+                expect(result.resolvedConfig.scalars[0]?.graphqlName).toBe("DateTime");
+                expect(result.resolvedConfig.scalars[0]?.typeName).toBe("DateTimeString");
+                expect(result.resolvedConfig.scalars[0]?.importPath).toBe("./src/types");
+            });
+            it("should accept only option for input-only scalar", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                                only: "input",
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars[0]?.only).toBe("input");
+            });
+            it("should accept only option for output-only scalar", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                                only: "output",
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars[0]?.only).toBe("output");
+            });
+            it("should default only to null when not specified", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars[0]?.only).toBe(null);
+            });
+            it("should accept description option", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                                description: "ISO 8601 date-time format",
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars[0]?.description).toBe("ISO 8601 date-time format");
+            });
+            it("should default description to null when not specified", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars[0]?.description).toBe(null);
+            });
+            it("should return error for invalid only value", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                                only: "invalid",
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_ONLY_VALUE");
+                expect(result.diagnostics[0]?.message).toContain("only");
+            });
+            it("should return error when name is missing in new format", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                tsType: { name: "Date" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_MISSING_PROPERTY");
+            });
+            it("should return error when tsType.name is missing", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: {},
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_MISSING_PROPERTY");
+                expect(result.diagnostics[0]?.message).toContain("tsType.name");
+            });
+            it("should allow multiple mappings for same scalar name with different only values", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "DateTime",
+                                tsType: { name: "Date" },
+                                only: "input",
+                            },
+                            {
+                                name: "DateTime",
+                                tsType: { name: "DateTimeOutput", from: "./src/types" },
+                                only: "output",
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.scalars.length).toBe(2);
+                expect(result.resolvedConfig.scalars[0]?.graphqlName).toBe("DateTime");
+                expect(result.resolvedConfig.scalars[0]?.only).toBe("input");
+                expect(result.resolvedConfig.scalars[1]?.graphqlName).toBe("DateTime");
+                expect(result.resolvedConfig.scalars[1]?.only).toBe("output");
+            });
+            it("should return error for built-in scalar override in new format", () => {
+                const result = validateConfig({
+                    config: {
+                        scalars: [
+                            {
+                                name: "String",
+                                tsType: { name: "CustomString" },
+                            },
+                        ],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_BUILTIN_OVERRIDE");
+            });
+        });
+        describe("output options (legacy tests - updated to new format)", () => {
+            it("should return error for invalid output type (not object)", () => {
+                const result = validateConfig({
+                    config: {
+                        output: "invalid",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("output");
+            });
+        });
+        describe("tsconfigPath options", () => {
+            it("should resolve tsconfigPath to null when not provided", () => {
+                const result = validateConfig({
+                    config: {},
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.tsconfigPath).toBe(null);
+            });
+            it("should accept string tsconfigPath", () => {
+                const result = validateConfig({
+                    config: {
+                        tsconfigPath: "./tsconfig.build.json",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.tsconfigPath).toBe("./tsconfig.build.json");
+            });
+            it("should return error for invalid tsconfigPath type", () => {
+                const result = validateConfig({
+                    config: {
+                        tsconfigPath: 123,
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("tsconfigPath");
+            });
+            it("should return error for empty tsconfigPath", () => {
+                const result = validateConfig({
+                    config: {
+                        tsconfigPath: "",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_PATH");
+                expect(result.diagnostics[0]?.message).toContain("empty");
+            });
+        });
+        describe("sourceDir options", () => {
+            it("should resolve default sourceDir when not provided", () => {
+                const result = validateConfig({
+                    config: {},
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.sourceDir).toBe("src/gqlkit/schema");
+            });
+            it("should accept valid sourceDir string", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceDir: "src/graphql",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.sourceDir).toBe("src/graphql");
+            });
+            it("should return error for empty sourceDir", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceDir: "",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_SOURCE_DIR");
+                expect(result.diagnostics[0]?.message).toContain("cannot be empty");
+            });
+            it("should return error for non-string sourceDir", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceDir: 123,
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("sourceDir");
+            });
+        });
+        describe("sourceIgnoreGlobs options", () => {
+            it("should resolve default sourceIgnoreGlobs when not provided", () => {
+                const result = validateConfig({
+                    config: {},
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.sourceIgnoreGlobs).toEqual([]);
+            });
+            it("should accept valid glob patterns array", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceIgnoreGlobs: ["**/*.test.ts", "**/__tests__/**"],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.sourceIgnoreGlobs).toEqual([
+                    "**/*.test.ts",
+                    "**/__tests__/**",
+                ]);
+            });
+            it("should accept empty array", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceIgnoreGlobs: [],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.sourceIgnoreGlobs).toEqual([]);
+            });
+            it("should return error for non-array sourceIgnoreGlobs", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceIgnoreGlobs: "**/*.test.ts",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_IGNORE_GLOBS");
+                expect(result.diagnostics[0]?.message).toContain("must be an array of strings");
+            });
+            it("should return error for array with non-string elements", () => {
+                const result = validateConfig({
+                    config: {
+                        sourceIgnoreGlobs: ["valid", 123, "also-valid"],
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_IGNORE_GLOBS");
+                expect(result.diagnostics[0]?.message).toContain("must be an array of strings");
+            });
+        });
+        describe("new output options (resolversPath, typeDefsPath, schemaPath)", () => {
+            it("should resolve default output paths when output is undefined", () => {
+                const result = validateConfig({
+                    config: {},
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.output.resolversPath).toBe("src/gqlkit/__generated__/resolvers.ts");
+                expect(result.resolvedConfig.output.typeDefsPath).toBe("src/gqlkit/__generated__/typeDefs.ts");
+                expect(result.resolvedConfig.output.schemaPath).toBe("src/gqlkit/__generated__/schema.graphql");
+            });
+            it("should resolve default paths when individual options are undefined", () => {
+                const result = validateConfig({
+                    config: { output: {} },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.output.resolversPath).toBe("src/gqlkit/__generated__/resolvers.ts");
+                expect(result.resolvedConfig.output.typeDefsPath).toBe("src/gqlkit/__generated__/typeDefs.ts");
+                expect(result.resolvedConfig.output.schemaPath).toBe("src/gqlkit/__generated__/schema.graphql");
+            });
+            it("should use custom paths when provided", () => {
+                const result = validateConfig({
+                    config: {
+                        output: {
+                            resolversPath: "custom/resolvers.ts",
+                            typeDefsPath: "custom/typeDefs.ts",
+                            schemaPath: "custom/schema.graphql",
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.output.resolversPath).toBe("custom/resolvers.ts");
+                expect(result.resolvedConfig.output.typeDefsPath).toBe("custom/typeDefs.ts");
+                expect(result.resolvedConfig.output.schemaPath).toBe("custom/schema.graphql");
+            });
+            it("should allow null to suppress output for each path", () => {
+                const result = validateConfig({
+                    config: {
+                        output: {
+                            resolversPath: null,
+                            typeDefsPath: null,
+                            schemaPath: null,
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.output.resolversPath).toBe(null);
+                expect(result.resolvedConfig.output.typeDefsPath).toBe(null);
+                expect(result.resolvedConfig.output.schemaPath).toBe(null);
+            });
+            it("should allow mixed null and string", () => {
+                const result = validateConfig({
+                    config: {
+                        output: {
+                            resolversPath: "custom/resolvers.ts",
+                            typeDefsPath: null,
+                            schemaPath: "custom/schema.graphql",
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.output.resolversPath).toBe("custom/resolvers.ts");
+                expect(result.resolvedConfig.output.typeDefsPath).toBe(null);
+                expect(result.resolvedConfig.output.schemaPath).toBe("custom/schema.graphql");
+            });
+            it("should return error for invalid resolversPath type", () => {
+                const result = validateConfig({
+                    config: {
+                        output: {
+                            resolversPath: 123,
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_OUTPUT_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("output.resolversPath");
+            });
+            it("should return error for invalid typeDefsPath type", () => {
+                const result = validateConfig({
+                    config: {
+                        output: {
+                            typeDefsPath: true,
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_OUTPUT_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("output.typeDefsPath");
+            });
+            it("should return error for empty string resolversPath", () => {
+                const result = validateConfig({
+                    config: {
+                        output: {
+                            resolversPath: "",
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_OUTPUT_PATH");
+                expect(result.diagnostics[0]?.message).toContain("empty");
+            });
+        });
+        describe("hooks options", () => {
+            it("should resolve default empty hooks when not provided", () => {
+                const result = validateConfig({
+                    config: {},
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.hooks.afterAllFileWrite).toEqual([]);
+            });
+            it("should accept single command string for afterAllFileWrite", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: "prettier --write",
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.hooks.afterAllFileWrite).toEqual([
+                    "prettier --write",
+                ]);
+            });
+            it("should accept array of command strings for afterAllFileWrite", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: ["prettier --write", "eslint --fix"],
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.hooks.afterAllFileWrite).toEqual([
+                    "prettier --write",
+                    "eslint --fix",
+                ]);
+            });
+            it("should accept empty array for afterAllFileWrite", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: [],
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.hooks.afterAllFileWrite).toEqual([]);
+            });
+            it("should accept hooks object without afterAllFileWrite", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {},
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(true);
+                expect(result.resolvedConfig).toBeTruthy();
+                expect(result.resolvedConfig.hooks.afterAllFileWrite).toEqual([]);
+            });
+            it("should return error for non-object hooks", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: "invalid",
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("hooks");
+            });
+            it("should return error for invalid afterAllFileWrite type", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: 123,
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_HOOK_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("afterAllFileWrite");
+            });
+            it("should return error for array with non-string elements", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: ["valid", 123, "also-valid"],
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_HOOK_TYPE");
+                expect(result.diagnostics[0]?.message).toContain("afterAllFileWrite");
+            });
+            it("should return error for empty command string", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: "",
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_HOOK_COMMAND");
+                expect(result.diagnostics[0]?.message).toContain("empty");
+            });
+            it("should return error for array containing empty string", () => {
+                const result = validateConfig({
+                    config: {
+                        hooks: {
+                            afterAllFileWrite: ["prettier --write", "", "eslint --fix"],
+                        },
+                    },
+                    configPath,
+                });
+                expect(result.valid).toBe(false);
+                expect(result.diagnostics.length).toBe(1);
+                expect(result.diagnostics[0]?.code).toBe("CONFIG_INVALID_HOOK_COMMAND");
+                expect(result.diagnostics[0]?.message).toContain("empty");
+            });
+        });
+    });
+});
+//# sourceMappingURL=validator.test.js.map