@likec4/config 1.47.0 → 1.49.0

package/src/node/load-config.ts

@@ -1,53 +1,128 @@
 import { invariant } from '@likec4/core'
+import { logger, wrapError } from '@likec4/log'
 import { bundleRequire } from 'bundle-require'
+import { defu } from 'defu'
+import { formatMessagesSync } from 'esbuild'
+import JSON5 from 'json5'
 import * as fs from 'node:fs/promises'
-import { dirname } from 'node:path'
-import type { URI } from 'vscode-uri'
-import { defineConfig } from '../define-config'
+import { basename, dirname, resolve } from 'node:path'
+import { hasAtLeast, isNonNullish, last, omit } from 'remeda'
+import z from 'zod/v4'
 import { isLikeC4JsonConfig, isLikeC4NonJsonConfig } from '../filenames'
-import { logger } from '../logger'
-import { type LikeC4ProjectConfig, validateProjectConfig } from '../schema'
+import type { LikeC4ProjectConfig, VscodeURI } from '../schema'
+import { LikeC4ProjectJsonConfigSchema, validateProjectConfig } from '../schema'
+
+const JsonConfigInputSchema = LikeC4ProjectJsonConfigSchema.pick({
+  extends: true,
+  styles: true,
+}).loose()
+
+type JsonConfigInput = z.infer<typeof JsonConfigInputSchema>
+type JsonConfigStyles = NonNullable<JsonConfigInput['styles']>
+
+const normalizeExtends = (value: JsonConfigInput['extends']): string[] => {
+  if (!value) {
+    return []
+  }
+  return Array.isArray(value) ? value : [value]
+}
+
+const parseJsonConfig = async (filepath: string): Promise<JsonConfigInput> => {
+  const content = await fs.readFile(filepath, 'utf-8')
+  let parsed: unknown
+  try {
+    parsed = JSON5.parse(content.trim() || '{}')
+  } catch (e) {
+    throw wrapError(e, `${filepath}:`)
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`${filepath}: Config must be a JSON object`)
+  }
+  const result = JsonConfigInputSchema.safeParse(parsed)
+  if (!result.success) {
+    throw new Error(`${filepath}: Invalid config\n` + z.prettifyError(result.error))
+  }
+  return result.data
+}
+
+const loadJsonConfigs = async (filepath: string, stack: string[]): Promise<[...JsonConfigInput[], JsonConfigInput]> => {
+  if (stack.includes(filepath)) {
+    const cycleStart = stack.indexOf(filepath)
+    const cycle = [...stack.slice(cycleStart), filepath].join(' -> ')
+    throw new Error(`Config extends cycle detected: ${cycle}`)
+  }
+
+  const parsed = await parseJsonConfig(filepath)
+  const extendsPaths = normalizeExtends(parsed.extends)
+  const nextStack = [...stack, filepath]
+
+  const configs: JsonConfigInput[] = []
+  for (const extendPath of extendsPaths) {
+    const resolvedPath = resolve(dirname(filepath), extendPath)
+    configs.push(...await loadJsonConfigs(resolvedPath, nextStack))
+  }
+  return [...configs, parsed]
+}
 
 /**
  * Load LikeC4 Project config file.
  * If filepath is a non-JSON file, it will be bundled and required
  */
-export async function loadConfig(filepath: URI): Promise<LikeC4ProjectConfig> {
-  logger.debug`Loading config file: ${filepath.fsPath}`
-  if (isLikeC4JsonConfig(filepath.fsPath)) {
-    try {
-      const content = await fs.readFile(filepath.fsPath, 'utf-8')
-      return validateProjectConfig(content)
-    } catch (err) {
-      logger.error(`Failed to load json config file: ${filepath.fsPath}`, { err })
-      throw err
-    }
+export async function loadConfig(filepath: VscodeURI | string): Promise<LikeC4ProjectConfig> {
+  filepath = typeof filepath === 'string' ? filepath : filepath.fsPath
+  logger.getChild('config').debug`Loading config: ${filepath}`
+
+  const folder = dirname(filepath)
+  const filename = basename(filepath)
+  const implicitcfg = { name: basename(folder) }
+
+  if (isLikeC4JsonConfig(filename)) {
+    const configs = await loadJsonConfigs(resolve(filepath), [])
+    invariant(hasAtLeast(configs, 1), 'Expect at least one config')
+    const rootConfig = omit(last(configs), ['extends', 'styles'])
+    const stylesChain = configs
+      .map(config => config.styles)
+      .filter(isNonNullish)
+
+    const mergedStyles = stylesChain.length > 0
+      ? defu({}, ...stylesChain.reverse())
+      : undefined
+
+    return validateProjectConfig({
+      ...implicitcfg,
+      ...rootConfig,
+      ...(mergedStyles ? { styles: mergedStyles } : {}),
+    })
   }
 
-  invariant(isLikeC4NonJsonConfig(filepath.fsPath), `Invalid config file: ${filepath.fsPath}`)
-  try {
-    const cwd = dirname(filepath.fsPath)
-    const { mod } = await bundleRequire({
-      filepath: filepath.fsPath,
-      cwd,
-      esbuildOptions: {
-        resolveExtensions: ['.mjs', '.js', '.ts', '.mts'],
-        plugins: [{
-          name: 'likec4-config',
-          setup(build) {
-            /**
-             * Intercept @likec4/config imports
-             */
-            build.onResolve({ filter: /^@?likec4\/config$/ }, (args) => ({
-              path: args.path,
-              namespace: 'likec4-config',
-            }))
-            /**
-             * Mock implementation, this allows to skip redundant bundling @likec4/config
-             */
-            build.onLoad({ filter: /.*/, namespace: 'likec4-config' }, (_args) => {
-              return {
-                contents: `
+  invariant(isLikeC4NonJsonConfig(filename), `Invalid name for config file: ${filepath}`)
+  const { mod } = await bundleRequire({
+    filepath,
+    cwd: folder,
+    esbuildOptions: {
+      resolveExtensions: ['.ts', '.mts', '.cts', '.mjs', '.js', '.cjs'],
+      plugins: [{
+        name: 'likec4-config',
+        setup(build) {
+          /**
+           * Intercept @likec4/config and likec4/config imports
+           */
+          build.onResolve({ filter: /^@?likec4\/config$/ }, (args) => ({
+            path: args.path,
+            namespace: 'likec4-config',
+          }))
+          build.onEnd((result) => {
+            const messages = formatMessagesSync(result.errors, { kind: 'error' })
+            for (const message of messages) {
+              logger.error(message)
+            }
+          })
+          /**
+           * Mock implementation, this allows to skip redundant bundling @likec4/config
+           */
+          build.onLoad({ filter: /.*/, namespace: 'likec4-config' }, (_args) => {
+            return {
+              contents: `
 // Mock implementation to allow loading config files without bundling @likec4/config
 function mock(x) { return x }
 export {
@@ -57,16 +132,12 @@ export {
   mock as defineTheme,
   mock as defineThemeColor,
 }`,
-                loader: 'js',
-              }
-            })
-          },
-        }],
-      },
-    })
-    return defineConfig(mod?.default ?? mod)
-  } catch (err) {
-    logger.error(`Failed to load config file: ${filepath.fsPath}`, { err })
-    throw err
-  }
+              loader: 'js',
+            }
+          })
+        },
+      }],
+    },
+  })
+  return validateProjectConfig(Object.assign(implicitcfg, mod?.default ?? mod))
 }

package/src/schema.image-alias.ts

@@ -1,10 +1,18 @@
-import * as z from 'zod'
+import z from 'zod/v4'
 
 // Key must be prefixed with "@" and contain only allowed characters
 const IMAGE_ALIAS_KEY_REGEX = /^@[A-Za-z0-9_-]*$/
 // Relative path (no leading slash, drive letter, or protocol)
 const IMAGE_ALIAS_VALUE_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/
 
+const ImageAliasKey = z
+  .string()
+  .min(1, 'Image alias key cannot be empty')
+  .regex(
+    IMAGE_ALIAS_KEY_REGEX,
+    'Image alias key must match /^@\\w+$/',
+  )
+
 // Schema for an image alias value: must be a non-empty string representing a relative path (no leading slash, drive letter, or protocol).
 const ImageAliasValue = z
   .string()
@@ -15,54 +23,10 @@ const ImageAliasValue = z
   )
 
 export const ImageAliasesSchema = z.record(
-  z.string(), // PLAIN key schema - zod JSON schema export-safe.
+  ImageAliasKey, // PLAIN key schema - zod JSON schema export-safe.
   ImageAliasValue,
 ).meta({
+  id: 'ImageAliases',
   description:
     'Map of image alias prefixes to relative paths (keys must match /^@\\w+$/; values must be relative paths without protocol or leading slash).',
 })
-
-// This just allows us to have a typed validate function.
-type LikeC4ImageAliasConfig = z.infer<typeof ImageAliasesSchema>
-
-export function validateImageAliases(imageAliases?: LikeC4ImageAliasConfig) {
-  const invalidKeys: string[] = []
-  const invalidValues: string[] = []
-
-  if (imageAliases) {
-    for (const [key, value] of Object.entries(imageAliases)) {
-      if (!IMAGE_ALIAS_KEY_REGEX.test(key)) {
-        invalidKeys.push(key)
-      }
-      // Value regex is technically already enforced by zod,
-      // so this check is purely defensive.
-      if (!IMAGE_ALIAS_VALUE_REGEX.test(value)) {
-        invalidValues.push(`${key} -> ${value}`)
-      }
-    }
-  }
-
-  if (invalidKeys.length || invalidValues.length) {
-    const parts: string[] = []
-    if (invalidKeys.length) {
-      parts.push(
-        `Invalid image alias key(s): ${
-          invalidKeys
-            .map((k) => JSON.stringify(k))
-            .join(', ')
-        } (must match ${IMAGE_ALIAS_KEY_REGEX})`,
-      )
-    }
-    if (invalidValues.length) {
-      parts.push(
-        `Invalid image alias value(s): ${
-          invalidValues
-            .map((kv) => JSON.stringify(kv))
-            .join(', ')
-        } (must match ${IMAGE_ALIAS_VALUE_REGEX})`,
-      )
-    }
-
-    throw new Error(parts.join(' | '))
-  }
-}

package/src/schema.include.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod'
+import z from 'zod/v4'
 
 // Relative path (no leading slash, drive letter, or protocol)
 // eslint-disable-next-line no-useless-escape
@@ -13,85 +13,47 @@ const IncludePathValue = z
     'Include path must be a relative path (no leading slash, drive letter, or protocol)',
   )
 
-export const IncludeConfigSchema = z.object({
-  paths: z.array(IncludePathValue)
-    .min(1, 'Include paths cannot be empty')
-    .meta({
-      description: [
-        'Additional relative directory paths to include LikeC4 source files from, searched recursively.',
-        'Paths are relative to the project folder (the folder containing this config file).',
-        'Example: ["../shared", "../common/specs"]',
-      ].join('\n'),
-    }),
-  maxDepth: z.number()
-    .int()
-    .min(1)
-    .max(20)
-    .default(3)
-    .meta({
-      description: [
-        'Maximum directory depth to scan when searching for .c4 files in include paths.',
-        'Prevents excessive scanning of deeply nested directories.',
-        'Default: 3',
-      ].join('\n'),
-    }),
-  fileThreshold: z.number()
-    .int()
-    .min(1)
-    .default(30)
-    .meta({
-      description: [
-        'Maximum number of files to load from include paths before warning.',
-        'Helps identify performance issues from accidentally including large directories.',
-        'Default: 30',
-      ].join('\n'),
-    }),
-})
-  .meta({
-    id: 'include-config',
-    description: 'Configuration for including additional LikeC4 source files',
+export const IncludeSchema = z
+  .strictObject({
+    paths: z.array(IncludePathValue)
+      .meta({
+        description: [
+          'Additional relative directory paths to include LikeC4 source files from, searched recursively.',
+          'Paths are relative to the project folder (the folder containing this config file).',
+          'Example: ["../shared", "../common/specs"]',
+        ].join('\n'),
+      }),
+    maxDepth: z.number()
+      .int()
+      .min(1)
+      .max(20)
+      .default(3)
+      .meta({
+        description: [
+          'Maximum directory depth to scan when searching for .c4 files in include paths.',
+          'Prevents excessive scanning of deeply nested directories.',
+          'Default: 3',
+        ].join('\n'),
+      }),
+    fileThreshold: z.number()
+      .int()
+      .min(1)
+      .max(10000)
+      .default(30)
+      .meta({
+        description: [
+          'Maximum number of files to load from include paths before warning.',
+          'Helps identify performance issues from accidentally including large directories.',
+          'Default: 30',
+        ].join('\n'),
+      }),
   })
-
-export type IncludeConfig = z.infer<typeof IncludeConfigSchema>
-
-export const IncludeSchema = IncludeConfigSchema
-  .optional()
   .meta({
+    id: 'include-config',
     description: [
       'Configuration for including additional LikeC4 source files from other directories.',
       'Example: { "paths": ["../shared", "../common/specs"], "maxDepth": 5, "fileThreshold": 50 }',
     ].join('\n'),
   })
 
-type LikeC4IncludeConfig = z.infer<typeof IncludeSchema>
-
-export function normalizeIncludeConfig(include?: LikeC4IncludeConfig): IncludeConfig {
-  if (!include) {
-    return { paths: [], maxDepth: 3, fileThreshold: 30 }
-  }
-  return include
-}
-
-export function validateIncludePaths(include?: LikeC4IncludeConfig) {
-  if (!include?.paths) {
-    return
-  }
-
-  const invalidPaths: string[] = []
-
-  for (const path of include.paths) {
-    if (!RELATIVE_PATH_REGEX.test(path)) {
-      invalidPaths.push(path)
-    }
-  }
-
-  if (invalidPaths.length) {
-    throw new Error(
-      `Invalid include path(s): ${
-        invalidPaths
-          .map((p) => JSON.stringify(p))
-          .join(', ')
-      } (must be relative paths without leading slash, drive letter, or protocol)`,
-    )
-  }
-}
+export type IncludeConfig = z.infer<typeof IncludeSchema>