c12.CEGFwQZa.mjs 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401
  1. import { statSync, promises, existsSync } from 'node:fs';
  2. import { rm, readFile } from 'node:fs/promises';
  3. import { pathToFileURL } from 'node:url';
  4. import { homedir } from 'node:os';
  5. import { resolve, join, dirname, basename, extname, normalize } from 'pathe';
  6. import { resolveModulePath } from 'exsolve';
  7. import { createJiti } from 'jiti';
  8. import * as rc9 from 'rc9';
  9. import { defu } from 'defu';
  10. import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
  11. import * as dotenv from 'dotenv';
  12. async function setupDotenv(options) {
  13. const targetEnvironment = options.env ?? process.env;
  14. const environment = await loadDotenv({
  15. cwd: options.cwd,
  16. fileName: options.fileName ?? ".env",
  17. env: targetEnvironment,
  18. interpolate: options.interpolate ?? true
  19. });
  20. const dotenvVars = getDotEnvVars(targetEnvironment);
  21. for (const key in environment) {
  22. if (key.startsWith("_")) {
  23. continue;
  24. }
  25. if (targetEnvironment[key] === void 0 || dotenvVars.has(key)) {
  26. targetEnvironment[key] = environment[key];
  27. }
  28. }
  29. return environment;
  30. }
  31. async function loadDotenv(options) {
  32. const environment = /* @__PURE__ */ Object.create(null);
  33. const dotenvFile = resolve(options.cwd, options.fileName);
  34. const dotenvVars = getDotEnvVars(options.env || {});
  35. Object.assign(environment, options.env);
  36. if (statSync(dotenvFile, { throwIfNoEntry: false })?.isFile()) {
  37. const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
  38. for (const key in parsed) {
  39. if (key in environment && !dotenvVars.has(key)) {
  40. continue;
  41. }
  42. environment[key] = parsed[key];
  43. dotenvVars.add(key);
  44. }
  45. }
  46. if (options.interpolate) {
  47. interpolate(environment);
  48. }
  49. return environment;
  50. }
  51. function interpolate(target, source = {}, parse = (v) => v) {
  52. function getValue(key) {
  53. return source[key] === void 0 ? target[key] : source[key];
  54. }
  55. function interpolate2(value, parents = []) {
  56. if (typeof value !== "string") {
  57. return value;
  58. }
  59. const matches = value.match(/(.?\${?(?:[\w:]+)?}?)/g) || [];
  60. return parse(
  61. // eslint-disable-next-line unicorn/no-array-reduce
  62. matches.reduce((newValue, match) => {
  63. const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || [];
  64. const prefix = parts[1];
  65. let value2, replacePart;
  66. if (prefix === "\\") {
  67. replacePart = parts[0] || "";
  68. value2 = replacePart.replace(String.raw`\$`, "$");
  69. } else {
  70. const key = parts[2];
  71. replacePart = (parts[0] || "").slice(prefix.length);
  72. if (parents.includes(key)) {
  73. console.warn(
  74. `Please avoid recursive environment variables ( loop: ${parents.join(
  75. " > "
  76. )} > ${key} )`
  77. );
  78. return "";
  79. }
  80. value2 = getValue(key);
  81. value2 = interpolate2(value2, [...parents, key]);
  82. }
  83. return value2 === void 0 ? newValue : newValue.replace(replacePart, value2);
  84. }, value)
  85. );
  86. }
  87. for (const key in target) {
  88. target[key] = interpolate2(getValue(key));
  89. }
  90. }
  91. function getDotEnvVars(targetEnvironment) {
  92. const globalRegistry = globalThis.__c12_dotenv_vars__ ||= /* @__PURE__ */ new Map();
  93. if (!globalRegistry.has(targetEnvironment)) {
  94. globalRegistry.set(targetEnvironment, /* @__PURE__ */ new Set());
  95. }
  96. return globalRegistry.get(targetEnvironment);
  97. }
  98. const _normalize = (p) => p?.replace(/\\/g, "/");
  99. const ASYNC_LOADERS = {
  100. ".yaml": () => import('confbox/yaml').then((r) => r.parseYAML),
  101. ".yml": () => import('confbox/yaml').then((r) => r.parseYAML),
  102. ".jsonc": () => import('confbox/jsonc').then((r) => r.parseJSONC),
  103. ".json5": () => import('confbox/json5').then((r) => r.parseJSON5),
  104. ".toml": () => import('confbox/toml').then((r) => r.parseTOML)
  105. };
  106. const SUPPORTED_EXTENSIONS = Object.freeze([
  107. // with jiti
  108. ".js",
  109. ".ts",
  110. ".mjs",
  111. ".cjs",
  112. ".mts",
  113. ".cts",
  114. ".json",
  115. // with confbox
  116. ".jsonc",
  117. ".json5",
  118. ".yaml",
  119. ".yml",
  120. ".toml"
  121. ]);
  122. async function loadConfig(options) {
  123. options.cwd = resolve(process.cwd(), options.cwd || ".");
  124. options.name = options.name || "config";
  125. options.envName = options.envName ?? process.env.NODE_ENV;
  126. options.configFile = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
  127. options.rcFile = options.rcFile ?? `.${options.name}rc`;
  128. if (options.extend !== false) {
  129. options.extend = {
  130. extendKey: "extends",
  131. ...options.extend
  132. };
  133. }
  134. const _merger = options.merger || defu;
  135. options.jiti = options.jiti || createJiti(join(options.cwd, options.configFile), {
  136. interopDefault: true,
  137. moduleCache: false,
  138. extensions: [...SUPPORTED_EXTENSIONS],
  139. ...options.jitiOptions
  140. });
  141. const r = {
  142. config: {},
  143. cwd: options.cwd,
  144. configFile: resolve(options.cwd, options.configFile),
  145. layers: []
  146. };
  147. const _configs = {
  148. overrides: options.overrides,
  149. main: void 0,
  150. rc: void 0,
  151. packageJson: void 0,
  152. defaultConfig: options.defaultConfig
  153. };
  154. if (options.dotenv) {
  155. await setupDotenv({
  156. cwd: options.cwd,
  157. ...options.dotenv === true ? {} : options.dotenv
  158. });
  159. }
  160. const _mainConfig = await resolveConfig(".", options);
  161. if (_mainConfig.configFile) {
  162. _configs.main = _mainConfig.config;
  163. r.configFile = _mainConfig.configFile;
  164. }
  165. if (_mainConfig.meta) {
  166. r.meta = _mainConfig.meta;
  167. }
  168. if (options.rcFile) {
  169. const rcSources = [];
  170. rcSources.push(rc9.read({ name: options.rcFile, dir: options.cwd }));
  171. if (options.globalRc) {
  172. const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => {
  173. });
  174. if (workspaceDir) {
  175. rcSources.push(rc9.read({ name: options.rcFile, dir: workspaceDir }));
  176. }
  177. rcSources.push(rc9.readUser({ name: options.rcFile, dir: options.cwd }));
  178. }
  179. _configs.rc = _merger({}, ...rcSources);
  180. }
  181. if (options.packageJson) {
  182. const keys = (Array.isArray(options.packageJson) ? options.packageJson : [
  183. typeof options.packageJson === "string" ? options.packageJson : options.name
  184. ]).filter((t) => t && typeof t === "string");
  185. const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => {
  186. });
  187. const values = keys.map((key) => pkgJsonFile?.[key]);
  188. _configs.packageJson = _merger({}, ...values);
  189. }
  190. const configs = {};
  191. for (const key in _configs) {
  192. const value = _configs[key];
  193. configs[key] = await (typeof value === "function" ? value({ configs }) : value);
  194. }
  195. r.config = _merger(
  196. configs.overrides,
  197. configs.main,
  198. configs.rc,
  199. configs.packageJson,
  200. configs.defaultConfig
  201. );
  202. if (options.extend) {
  203. await extendConfig(r.config, options);
  204. r.layers = r.config._layers;
  205. delete r.config._layers;
  206. r.config = _merger(r.config, ...r.layers.map((e) => e.config));
  207. }
  208. const baseLayers = [
  209. configs.overrides && {
  210. config: configs.overrides,
  211. configFile: void 0,
  212. cwd: void 0
  213. },
  214. { config: configs.main, configFile: options.configFile, cwd: options.cwd },
  215. configs.rc && { config: configs.rc, configFile: options.rcFile },
  216. configs.packageJson && {
  217. config: configs.packageJson,
  218. configFile: "package.json"
  219. }
  220. ].filter((l) => l && l.config);
  221. r.layers = [...baseLayers, ...r.layers];
  222. if (options.defaults) {
  223. r.config = _merger(r.config, options.defaults);
  224. }
  225. if (options.omit$Keys) {
  226. for (const key in r.config) {
  227. if (key.startsWith("$")) {
  228. delete r.config[key];
  229. }
  230. }
  231. }
  232. return r;
  233. }
  234. async function extendConfig(config, options) {
  235. config._layers = config._layers || [];
  236. if (!options.extend) {
  237. return;
  238. }
  239. let keys = options.extend.extendKey;
  240. if (typeof keys === "string") {
  241. keys = [keys];
  242. }
  243. const extendSources = [];
  244. for (const key of keys) {
  245. extendSources.push(
  246. ...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter(
  247. Boolean
  248. )
  249. );
  250. delete config[key];
  251. }
  252. for (let extendSource of extendSources) {
  253. const originalExtendSource = extendSource;
  254. let sourceOptions = {};
  255. if (extendSource.source) {
  256. sourceOptions = extendSource.options || {};
  257. extendSource = extendSource.source;
  258. }
  259. if (Array.isArray(extendSource)) {
  260. sourceOptions = extendSource[1] || {};
  261. extendSource = extendSource[0];
  262. }
  263. if (typeof extendSource !== "string") {
  264. console.warn(
  265. `Cannot extend config from \`${JSON.stringify(
  266. originalExtendSource
  267. )}\` in ${options.cwd}`
  268. );
  269. continue;
  270. }
  271. const _config = await resolveConfig(extendSource, options, sourceOptions);
  272. if (!_config.config) {
  273. console.warn(
  274. `Cannot extend config from \`${extendSource}\` in ${options.cwd}`
  275. );
  276. continue;
  277. }
  278. await extendConfig(_config.config, { ...options, cwd: _config.cwd });
  279. config._layers.push(_config);
  280. if (_config.config._layers) {
  281. config._layers.push(..._config.config._layers);
  282. delete _config.config._layers;
  283. }
  284. }
  285. }
  286. const GIGET_PREFIXES = [
  287. "gh:",
  288. "github:",
  289. "gitlab:",
  290. "bitbucket:",
  291. "https://",
  292. "http://"
  293. ];
  294. const NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
  295. async function resolveConfig(source, options, sourceOptions = {}) {
  296. if (options.resolve) {
  297. const res2 = await options.resolve(source, options);
  298. if (res2) {
  299. return res2;
  300. }
  301. }
  302. const _merger = options.merger || defu;
  303. const customProviderKeys = Object.keys(
  304. sourceOptions.giget?.providers || {}
  305. ).map((key) => `${key}:`);
  306. const gigetPrefixes = customProviderKeys.length > 0 ? [.../* @__PURE__ */ new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
  307. if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
  308. const { downloadTemplate } = await import('giget');
  309. const { digest } = await import('ohash');
  310. const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
  311. let cloneDir;
  312. const localNodeModules = resolve(options.cwd, "node_modules");
  313. const parentDir = dirname(options.cwd);
  314. if (basename(parentDir) === ".c12") {
  315. cloneDir = join(parentDir, cloneName);
  316. } else if (existsSync(localNodeModules)) {
  317. cloneDir = join(localNodeModules, ".c12", cloneName);
  318. } else {
  319. cloneDir = process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "c12", cloneName) : resolve(homedir(), ".cache/c12", cloneName);
  320. }
  321. if (existsSync(cloneDir) && !sourceOptions.install) {
  322. await rm(cloneDir, { recursive: true });
  323. }
  324. const cloned = await downloadTemplate(source, {
  325. dir: cloneDir,
  326. install: sourceOptions.install,
  327. force: sourceOptions.install,
  328. auth: sourceOptions.auth,
  329. ...options.giget,
  330. ...sourceOptions.giget
  331. });
  332. source = cloned.dir;
  333. }
  334. if (NPM_PACKAGE_RE.test(source)) {
  335. source = tryResolve(source, options) || source;
  336. }
  337. const ext = extname(source);
  338. const isDir = !ext || ext === basename(source);
  339. const cwd = resolve(options.cwd, isDir ? source : dirname(source));
  340. if (isDir) {
  341. source = options.configFile;
  342. }
  343. const res = {
  344. config: void 0,
  345. configFile: void 0,
  346. cwd,
  347. source,
  348. sourceOptions
  349. };
  350. res.configFile = tryResolve(resolve(cwd, source), options) || tryResolve(
  351. resolve(cwd, ".config", source.replace(/\.config$/, "")),
  352. options
  353. ) || tryResolve(resolve(cwd, ".config", source), options) || source;
  354. if (!existsSync(res.configFile)) {
  355. return res;
  356. }
  357. const configFileExt = extname(res.configFile) || "";
  358. if (configFileExt in ASYNC_LOADERS) {
  359. const asyncLoader = await ASYNC_LOADERS[configFileExt]();
  360. const contents = await readFile(res.configFile, "utf8");
  361. res.config = asyncLoader(contents);
  362. } else {
  363. res.config = await options.jiti.import(res.configFile, {
  364. default: true
  365. });
  366. }
  367. if (res.config instanceof Function) {
  368. res.config = await res.config();
  369. }
  370. if (options.envName) {
  371. const envConfig = {
  372. ...res.config["$" + options.envName],
  373. ...res.config.$env?.[options.envName]
  374. };
  375. if (Object.keys(envConfig).length > 0) {
  376. res.config = _merger(envConfig, res.config);
  377. }
  378. }
  379. res.meta = defu(res.sourceOptions.meta, res.config.$meta);
  380. delete res.config.$meta;
  381. if (res.sourceOptions.overrides) {
  382. res.config = _merger(res.sourceOptions.overrides, res.config);
  383. }
  384. res.configFile = _normalize(res.configFile);
  385. res.source = _normalize(res.source);
  386. return res;
  387. }
  388. function tryResolve(id, options) {
  389. const res = resolveModulePath(id, {
  390. try: true,
  391. from: pathToFileURL(join(options.cwd || ".", options.configFile || "/")),
  392. suffixes: ["", "/index"],
  393. extensions: SUPPORTED_EXTENSIONS,
  394. cache: false
  395. });
  396. return res ? normalize(res) : void 0;
  397. }
  398. export { SUPPORTED_EXTENSIONS as S, loadDotenv as a, loadConfig as l, setupDotenv as s };