@clisma/config 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+export type MigrationConfig = {
+    dir: string;
+    table_name?: string;
+    replication_path?: string;
+    vars?: Record<string, unknown>;
+};
+export type EnvConfig = {
+    url: string;
+    exclude?: string[];
+    cluster_name?: string;
+    migrations: MigrationConfig;
+};
+export type VariableConfig = {
+    type: string;
+    default?: unknown;
+    description?: string;
+};
+export type ClismaConfig = {
+    env: Record<string, EnvConfig>;
+    variable?: Record<string, VariableConfig>;
+};
+/**
+ * Parses HCL config file and returns normalized configuration
+ */
+export declare const parseConfig: (content: string, env?: Record<string, string | undefined>, vars?: Record<string, string>, envName?: string, sourceName?: string) => Promise<EnvConfig>;
+export declare const parseConfigFile: (configPath: string, envName?: string, vars?: Record<string, string>, env?: Record<string, string | undefined>) => Promise<EnvConfig>;
+export declare const listEnvironments: (content: string, sourceName?: string) => Promise<string[]>;
+export declare const listEnvironmentsFile: (configPath: string) => Promise<string[]>;
+/**
+ * Finds config file in current directory or parent directories
+ */
+export declare const findConfigFile: (startDir?: string, fileName?: string) => Promise<string | null>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C,CAAC;AA2BF;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,EACf,MAAK,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAM,EAC5C,OAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACjC,UAAU,MAAM,EAChB,aAAY,MAAqB,KAChC,OAAO,CAAC,SAAS,CA4GnB,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,YAAY,MAAM,EAClB,UAAU,MAAM,EAChB,OAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACjC,MAAK,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,KACpD,OAAO,CAAC,SAAS,CAInB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,EACf,aAAY,MAAqB,KAChC,OAAO,CAAC,MAAM,EAAE,CAMlB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,KACjB,OAAO,CAAC,MAAM,EAAE,CAGlB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,WAAU,MAAsB,EAChC,WAAU,MAAqB,KAC9B,OAAO,CAAC,MAAM,GAAG,IAAI,CAmBvB,CAAC"}

package/dist/config.js

@@ -0,0 +1,118 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse } from "@cdktf/hcl2json";
+import { extractList, extractObject, extractValue, resolveValue, } from "./utils.js";
+// Helpers live in ./utils.ts to keep parsing logic focused.
+/**
+ * Parses HCL config file and returns normalized configuration
+ */
+export const parseConfig = async (content, env = {}, vars = {}, envName, sourceName = "clisma.hcl") => {
+    const parsed = (await parse(sourceName, content));
+    if (!parsed.env) {
+        throw new Error("No environments defined in config file");
+    }
+    // Parse variables
+    const variables = { ...vars };
+    if (parsed.variable) {
+        for (const [varName, varBlocks] of Object.entries(parsed.variable)) {
+            const varBlock = varBlocks[0];
+            if (varBlock?.default && !variables[varName]) {
+                const defaultValue = extractValue(varBlock.default, "");
+                variables[varName] = String(defaultValue);
+            }
+        }
+    }
+    // Determine which environment to use
+    const targetEnv = envName || Object.keys(parsed.env)[0];
+    if (!targetEnv) {
+        throw new Error("No environment specified and no default environment found");
+    }
+    const envBlocks = parsed.env[targetEnv];
+    if (!envBlocks || envBlocks.length === 0) {
+        throw new Error(`Environment "${targetEnv}" not found in config file`);
+    }
+    const envBlock = envBlocks[0];
+    // Parse migrations config
+    const migrationBlock = envBlock.migrations?.[0];
+    if (!migrationBlock) {
+        throw new Error(`No migrations configuration found for environment "${targetEnv}"`);
+    }
+    const migrationDir = extractValue(migrationBlock.dir, "");
+    if (!migrationDir) {
+        throw new Error(`Migrations directory not specified for environment "${targetEnv}"`);
+    }
+    // Parse migration vars and resolve them
+    const rawVars = extractObject(migrationBlock.vars, {});
+    const resolvedVars = {};
+    for (const [key, value] of Object.entries(rawVars)) {
+        if (typeof value === "string") {
+            resolvedVars[key] = resolveValue(value, env, variables);
+        }
+        else {
+            resolvedVars[key] = value;
+        }
+    }
+    // Parse optional table_name
+    const tableName = migrationBlock.table_name
+        ? extractValue(migrationBlock.table_name, "schema_migrations")
+        : "schema_migrations";
+    const replicationPath = migrationBlock.replication_path
+        ? resolveValue(extractValue(migrationBlock.replication_path, ""), env, variables) || undefined
+        : undefined;
+    // Parse URL
+    const url = extractValue(envBlock.url, "");
+    if (!url) {
+        throw new Error(`Database URL not specified for environment "${targetEnv}"`);
+    }
+    const clusterNameValue = envBlock.cluster_name
+        ? resolveValue(extractValue(envBlock.cluster_name, ""), env, variables)
+        : "";
+    const clusterName = clusterNameValue || undefined;
+    // Parse exclude patterns (optional)
+    const excludePatterns = extractList(envBlock.exclude, []);
+    return {
+        url: resolveValue(url, env, variables),
+        exclude: excludePatterns,
+        cluster_name: clusterName,
+        migrations: {
+            dir: resolveValue(migrationDir, env, variables),
+            table_name: tableName,
+            replication_path: replicationPath,
+            vars: resolvedVars,
+        },
+    };
+};
+export const parseConfigFile = async (configPath, envName, vars = {}, env = process.env) => {
+    const content = await fs.readFile(configPath, "utf8");
+    return parseConfig(content, env, vars, envName, configPath);
+};
+export const listEnvironments = async (content, sourceName = "clisma.hcl") => {
+    const parsed = (await parse(sourceName, content));
+    if (!parsed.env) {
+        return [];
+    }
+    return Object.keys(parsed.env);
+};
+export const listEnvironmentsFile = async (configPath) => {
+    const content = await fs.readFile(configPath, "utf8");
+    return listEnvironments(content, configPath);
+};
+/**
+ * Finds config file in current directory or parent directories
+ */
+export const findConfigFile = async (startDir = process.cwd(), fileName = "clisma.hcl") => {
+    let currentDir = startDir;
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const configPath = path.join(currentDir, fileName);
+        try {
+            await fs.access(configPath);
+            return configPath;
+        }
+        catch {
+            // File not found, continue searching
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+};

package/dist/hcl-schema.d.ts

@@ -0,0 +1,105 @@
+export declare const clismaSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "clisma.hcl";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly env: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/$defs/envBlock";
+                };
+            };
+        };
+        readonly variable: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/$defs/variableBlock";
+                };
+            };
+        };
+    };
+    readonly $defs: {
+        readonly envBlock: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["url", "migrations"];
+            readonly properties: {
+                readonly url: {
+                    readonly type: "string";
+                    readonly description: "ClickHouse connection string.";
+                };
+                readonly cluster_name: {
+                    readonly type: "string";
+                    readonly description: "Optional cluster name. When set, migrations use replicated tracking and templating.";
+                };
+                readonly exclude: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Optional glob patterns to exclude tables.";
+                };
+                readonly migrations: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/migrationsBlock";
+                    };
+                };
+            };
+        };
+        readonly migrationsBlock: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["dir"];
+            readonly properties: {
+                readonly dir: {
+                    readonly type: "string";
+                    readonly description: "Path to migrations directory.";
+                };
+                readonly table_name: {
+                    readonly type: "string";
+                    readonly description: "Custom table name for migration tracking.";
+                };
+                readonly replication_path: {
+                    readonly type: "string";
+                    readonly description: "Optional replication path for the migrations table in clustered setups.";
+                };
+                readonly vars: {
+                    readonly type: "object";
+                    readonly description: "Variables for Handlebars templates.";
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/variableValue";
+                    };
+                };
+            };
+        };
+        readonly variableBlock: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly description: "Variable type.";
+                    readonly enum: readonly ["string", "number", "bool", "any"];
+                };
+                readonly default: {
+                    readonly $ref: "#/$defs/variableValue";
+                };
+                readonly description: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly variableValue: {
+            readonly type: readonly ["string", "number", "boolean", "object", "array", "null"];
+        };
+    };
+};
+export declare const generateSchema: () => typeof clismaSchema;
+//# sourceMappingURL=hcl-schema.d.ts.map

package/dist/hcl-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcl-schema.d.ts","sourceRoot":"","sources":["../src/hcl-schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGf,CAAC;AAEX,eAAO,MAAM,cAAc,QAAO,OAAO,YAExC,CAAC"}

package/dist/hcl-schema.js

@@ -0,0 +1,106 @@
+export const clismaSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "clisma.hcl",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        env: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    $ref: "#/$defs/envBlock",
+                },
+            },
+        },
+        variable: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    $ref: "#/$defs/variableBlock",
+                },
+            },
+        },
+    },
+    $defs: {
+        envBlock: {
+            type: "object",
+            additionalProperties: false,
+            required: ["url", "migrations"],
+            properties: {
+                url: {
+                    type: "string",
+                    description: "ClickHouse connection string.",
+                },
+                cluster_name: {
+                    type: "string",
+                    description: "Optional cluster name. When set, migrations use replicated tracking and templating.",
+                },
+                exclude: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Optional glob patterns to exclude tables.",
+                },
+                migrations: {
+                    type: "array",
+                    items: {
+                        $ref: "#/$defs/migrationsBlock",
+                    },
+                },
+            },
+        },
+        migrationsBlock: {
+            type: "object",
+            additionalProperties: false,
+            required: ["dir"],
+            properties: {
+                dir: {
+                    type: "string",
+                    description: "Path to migrations directory.",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Custom table name for migration tracking.",
+                },
+                replication_path: {
+                    type: "string",
+                    description: "Optional replication path for the migrations table in clustered setups.",
+                },
+                vars: {
+                    type: "object",
+                    description: "Variables for Handlebars templates.",
+                    additionalProperties: {
+                        $ref: "#/$defs/variableValue",
+                    },
+                },
+            },
+        },
+        variableBlock: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type"],
+            properties: {
+                type: {
+                    type: "string",
+                    description: "Variable type.",
+                    enum: ["string", "number", "bool", "any"],
+                },
+                default: {
+                    $ref: "#/$defs/variableValue",
+                },
+                description: {
+                    type: "string",
+                },
+            },
+        },
+        variableValue: {
+            type: ["string", "number", "boolean", "object", "array", "null"],
+        },
+    },
+};
+export const generateSchema = () => {
+    return clismaSchema;
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./config.js";
+export { clismaSchema, generateSchema } from "./hcl-schema.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./config.js";
+export { clismaSchema, generateSchema } from "./hcl-schema.js";

package/dist/schema.d.ts

@@ -0,0 +1,96 @@
+export declare const clismaSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "clisma.hcl";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly env: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/$defs/envBlock";
+                };
+            };
+        };
+        readonly variable: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/$defs/variableBlock";
+                };
+            };
+        };
+    };
+    readonly $defs: {
+        readonly envBlock: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["url", "migration"];
+            readonly properties: {
+                readonly url: {
+                    readonly type: "string";
+                    readonly description: "ClickHouse connection string.";
+                };
+                readonly exclude: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Optional glob patterns to exclude tables.";
+                };
+                readonly migration: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/migrationBlock";
+                    };
+                };
+            };
+        };
+        readonly migrationBlock: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["dir"];
+            readonly properties: {
+                readonly dir: {
+                    readonly type: "string";
+                    readonly description: "Path to migrations directory.";
+                };
+                readonly table_name: {
+                    readonly type: "string";
+                    readonly description: "Custom table name for migration tracking.";
+                };
+                readonly vars: {
+                    readonly type: "object";
+                    readonly description: "Variables for Handlebars templates.";
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/variableValue";
+                    };
+                };
+            };
+        };
+        readonly variableBlock: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["type"];
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly description: "Variable type.";
+                    readonly enum: readonly ["string", "number", "bool", "any"];
+                };
+                readonly default: {
+                    readonly $ref: "#/$defs/variableValue";
+                };
+                readonly description: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly variableValue: {
+            readonly type: readonly ["string", "number", "boolean", "object", "array", "null"];
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Ff,CAAC"}

package/dist/schema.js

@@ -0,0 +1,95 @@
+export const clismaSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "clisma.hcl",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        env: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    $ref: "#/$defs/envBlock",
+                },
+            },
+        },
+        variable: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    $ref: "#/$defs/variableBlock",
+                },
+            },
+        },
+    },
+    $defs: {
+        envBlock: {
+            type: "object",
+            additionalProperties: false,
+            required: ["url", "migration"],
+            properties: {
+                url: {
+                    type: "string",
+                    description: "ClickHouse connection string.",
+                },
+                exclude: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                    description: "Optional glob patterns to exclude tables.",
+                },
+                migration: {
+                    type: "array",
+                    items: {
+                        $ref: "#/$defs/migrationBlock",
+                    },
+                },
+            },
+        },
+        migrationBlock: {
+            type: "object",
+            additionalProperties: false,
+            required: ["dir"],
+            properties: {
+                dir: {
+                    type: "string",
+                    description: "Path to migrations directory.",
+                },
+                table_name: {
+                    type: "string",
+                    description: "Custom table name for migration tracking.",
+                },
+                vars: {
+                    type: "object",
+                    description: "Variables for Handlebars templates.",
+                    additionalProperties: {
+                        $ref: "#/$defs/variableValue",
+                    },
+                },
+            },
+        },
+        variableBlock: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type"],
+            properties: {
+                type: {
+                    type: "string",
+                    description: "Variable type.",
+                    enum: ["string", "number", "bool", "any"],
+                },
+                default: {
+                    $ref: "#/$defs/variableValue",
+                },
+                description: {
+                    type: "string",
+                },
+            },
+        },
+        variableValue: {
+            type: ["string", "number", "boolean", "object", "array", "null"],
+        },
+    },
+};

package/dist/tests/parse-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parse-config.test.d.ts.map

package/dist/tests/parse-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-config.test.d.ts","sourceRoot":"","sources":["../../src/tests/parse-config.test.ts"],"names":[],"mappings":""}

package/dist/tests/parse-config.test.js

@@ -0,0 +1,33 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseConfig } from "../config.js";
+const SAMPLE_HCL = `
+env "local" {
+  url = env("CLICKHOUSE_URL")
+
+  migrations {
+    dir = "migrations/\${var.ttl_days}"
+
+    vars = {
+      ttl = var.ttl_days
+      ttl_static = "var.ttl_days"
+      ttl_unexisting = var.non_existing_var
+    }
+  }
+}
+
+variable "ttl_days" {
+  type = string
+  default = "30"
+}
+`;
+test("parseConfig resolves env() and var.* values", async () => {
+    const config = await parseConfig(SAMPLE_HCL, {
+        CLICKHOUSE_URL: "lol",
+    }, {}, "local");
+    assert.equal(config.url, "lol");
+    assert.equal(config.migrations.dir, "migrations/30");
+    assert.equal(config.migrations.vars?.ttl, "30");
+    assert.equal(config.migrations.vars?.ttl_static, "var.ttl_days");
+    assert.equal(config.migrations.vars?.ttl_unexisting, "");
+});

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const resolveValue: (value: string, env?: Record<string, string | undefined>, vars?: Record<string, string>) => string;
+export declare const extractValue: <T>(value: T[] | T | undefined, defaultValue: T) => T;
+export declare const extractObject: <T extends Record<string, unknown>>(value: T[] | T | undefined, defaultValue: T) => T;
+export declare const extractList: <T>(value: T[] | T[][] | undefined, defaultValue: T[]) => T[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,EACb,MAAK,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAM,EAC5C,OAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,KAChC,MAoBF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,EAC5B,OAAO,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,EAC1B,cAAc,CAAC,KACd,CAKF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,OAAO,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,EAC1B,cAAc,CAAC,KACd,CAKF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,SAAS,EAC9B,cAAc,CAAC,EAAE,KAChB,CAAC,EAYH,CAAC"}

package/dist/utils.js

@@ -0,0 +1,42 @@
+export const resolveValue = (value, env = {}, vars = {}) => {
+    const envCallRegex = /^env\("([^"]+)"\)$/;
+    const varRefRegex = /^var\.(\w+)$/;
+    const interpolationRegex = /\$\{([^}]+)\}/g;
+    const resolved = value.replace(interpolationRegex, (match, expr) => {
+        const envExprMatch = expr.match(envCallRegex);
+        if (envExprMatch) {
+            return env[envExprMatch[1]] || "";
+        }
+        const varExprMatch = expr.match(varRefRegex);
+        if (varExprMatch) {
+            return vars[varExprMatch[1]] || "";
+        }
+        return match;
+    });
+    return resolved;
+};
+export const extractValue = (value, defaultValue) => {
+    if (Array.isArray(value) && value.length > 0) {
+        return value[0];
+    }
+    return value !== undefined ? value : defaultValue;
+};
+export const extractObject = (value, defaultValue) => {
+    if (Array.isArray(value)) {
+        return value[0] || defaultValue;
+    }
+    return value !== undefined ? value : defaultValue;
+};
+export const extractList = (value, defaultValue) => {
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return defaultValue;
+        }
+        const first = value[0];
+        if (Array.isArray(first)) {
+            return first;
+        }
+        return value;
+    }
+    return defaultValue;
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@clisma/config",
+  "version": "0.1.0",
+  "description": "Configuration parsing and schema generation for clisma",
+  "type": "module",
+  "main": "dist/config.js",
+  "types": "dist/config.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@cdktf/hcl2json": "^0.21.0"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "test": "node --import tsx --test src/tests/*.test.ts",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src",
+    "format": "oxfmt --check src",
+    "format:fix": "oxfmt src"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.4.0",
+    "oxlint": "^0.12.0"
+  }
+}