Add support for default export in dynamicInclude method

Author: noxify

.changeset/dynamic-include-default-export.md

@@ -0,0 +1,5 @@
+---
+"@noxify/gitlab-ci-builder": patch
+---
+
+Add support for default export in `dynamicInclude`. Config modules can now use either `export default function(config: Config)` or the existing `export function extendConfig(config: Config)`. Default export is preferred when both are present.

src/config.ts

@@ -332,9 +332,9 @@ export class Config {
    * Dynamically include other TypeScript configuration modules by glob.
    *
    * For every file matched by `globs` (resolved relative to `cwd`), this method
-   * will `import()` the file and call its exported `extendConfig` function with
-   * this `Config` instance. The imported file must export an `extendConfig`
-   * function; otherwise an error is thrown.
+   * will `import()` the file and call its exported function with this `Config`
+   * instance. The imported file must export either a default export function or
+   * a named `extendConfig` function; otherwise an error is thrown.
    *
    * @param cwd - Base directory for the globs (use `process.cwd()` normally).
    * @param globs - Glob patterns to match files (tinyglobby semantics).
@@ -350,16 +350,22 @@ export class Config {
       for (const file of files) {
         // eslint-disable-next-line no-console
         console.log(`Include file "${file}..."`)
-        const exported = (await import(file)) as { extendConfig?: ExtendConfigFunction } | undefined
-        if (!exported?.extendConfig) {
-          throw new Error(`Please export a function extendConfig which returns a Config instance!`)
+        const exported = (await import(file)) as
+          | { default?: ExtendConfigFunction; extendConfig?: ExtendConfigFunction }
+          | undefined
+
+        // Prefer default export, fallback to named extendConfig
+        const extendFn = exported?.default ?? exported?.extendConfig
+
+        if (!extendFn) {
+          throw new Error(`Please export a default function or a named "extendConfig" function!`)
         }
 
-        if (!(exported.extendConfig instanceof Function)) {
-          throw new Error(`The exported extendConfig is not a function!`)
+        if (!(extendFn instanceof Function)) {
+          throw new Error(`The exported function is not a function!`)
         }
 
-        await exported.extendConfig(this)
+        await extendFn(this)
       }
     }
   }

tests/config.edgecases.test.ts

@@ -14,15 +14,15 @@ describe("Config - edge cases and branches", () => {
     const fixtures = new URL("./fixtures", import.meta.url).pathname
 
     await expect(cfg.dynamicInclude(fixtures, ["no-export.mjs"])).rejects.toThrow(
-      /Please export a function extendConfig/i,
+      /Please export a default function or a named "extendConfig" function!/i,
     )
   })
 
   it("throws if extendConfig is not a function", async () => {
     const fixtures = new URL("./fixtures", import.meta.url).pathname
 
     await expect(cfg.dynamicInclude(fixtures, ["extend-not-fn.mjs"])).rejects.toThrow(
-      /The exported extendConfig is not a function/i,
+      /The exported function is not a function!/i,
     )
   })
 

tests/dynamic-include.test.ts

@@ -19,11 +19,15 @@ describe("Config - include", () => {
   it("should throw error when extendConfig is not exported", async () => {
     vi.mocked(globSync).mockReturnValue(["/fake/file.ts"])
 
-    // Mock the import to return an empty object
-    vi.doMock("/fake/file.ts", () => ({ default: {} }))
+    // Mock the import to return an object without default or extendConfig
+    vi.doMock("/fake/file.ts", () => ({
+      default: undefined,
+      extendConfig: undefined,
+      someOtherExport: "value",
+    }))
 
     await expect(config.dynamicInclude(process.cwd(), ["*.ts"])).rejects.toThrow(
-      /Please export a function extendConfig|No "extendConfig" export/,
+      /Please export a default function or a named "extendConfig" function!/,
     )
 
     vi.doUnmock("/fake/file.ts")
@@ -34,12 +38,15 @@ describe("Config - include", () => {
 
     // Mock dynamic import with extendConfig as non-function
     vi.doMock("/fake/file.ts", () => ({
+      default: undefined,
       extendConfig: "not-a-function",
     }))
 
     await expect(config.dynamicInclude(process.cwd(), ["*.ts"])).rejects.toThrow(
-      "The exported extendConfig is not a function!",
+      "The exported function is not a function!",
     )
+
+    vi.doUnmock("/fake/file.ts")
   })
 
   it("should call extendConfig for each matched file", async () => {
@@ -51,10 +58,12 @@ describe("Config - include", () => {
 
     // Mock dynamic imports
     vi.doMock("/fake/file1.ts", () => ({
+      default: undefined,
       extendConfig: mockExtendConfig,
     }))
 
     vi.doMock("/fake/file2.ts", () => ({
+      default: undefined,
       extendConfig: mockExtendConfig,
     }))
 
@@ -63,6 +72,9 @@ describe("Config - include", () => {
     // extendConfig should be called for each file
     expect(mockExtendConfig).toHaveBeenCalledTimes(2)
     expect(mockExtendConfig).toHaveBeenCalledWith(config)
+
+    vi.doUnmock("/fake/file1.ts")
+    vi.doUnmock("/fake/file2.ts")
   })
 
   it("should pass correct glob options", async () => {
@@ -94,16 +106,59 @@ describe("Config - include", () => {
       .mockReturnValueOnce(["/fake/config2.ts"])
 
     vi.doMock("/fake/config1.ts", () => ({
+      default: undefined,
       extendConfig: mockExtendConfig,
     }))
 
     vi.doMock("/fake/config2.ts", () => ({
+      default: undefined,
       extendConfig: mockExtendConfig,
     }))
 
     await config.dynamicInclude(process.cwd(), ["configs/*.ts", "pipelines/*.ts"])
 
     expect(globSync).toHaveBeenCalledTimes(2)
     expect(mockExtendConfig).toHaveBeenCalledTimes(2)
+
+    vi.doUnmock("/fake/config1.ts")
+    vi.doUnmock("/fake/config2.ts")
+  })
+
+  it("should support default export", async () => {
+    const mockExtendConfig = vi.fn((cfg: Config) => {
+      cfg.job("default-job", { script: ["echo default"] })
+    })
+
+    vi.mocked(globSync).mockReturnValue(["/fake/default.ts"])
+
+    vi.doMock("/fake/default.ts", () => ({
+      default: mockExtendConfig,
+    }))
+
+    await config.dynamicInclude(process.cwd(), ["*.ts"])
+
+    expect(mockExtendConfig).toHaveBeenCalledTimes(1)
+    expect(mockExtendConfig).toHaveBeenCalledWith(config)
+
+    vi.doUnmock("/fake/default.ts")
+  })
+
+  it("should prefer default export over named extendConfig", async () => {
+    const mockDefault = vi.fn()
+    const mockNamed = vi.fn()
+
+    vi.mocked(globSync).mockReturnValue(["/fake/both.ts"])
+
+    vi.doMock("/fake/both.ts", () => ({
+      default: mockDefault,
+      extendConfig: mockNamed,
+    }))
+
+    await config.dynamicInclude(process.cwd(), ["*.ts"])
+
+    expect(mockDefault).toHaveBeenCalledTimes(1)
+    expect(mockNamed).not.toHaveBeenCalled()
+
+    vi.doUnmock("/fake/both.ts")
   })
 })