@coreframe/config 0.0.0 → 0.1.0

package/dist/environment.d.ts

@@ -0,0 +1,11 @@
+import { stat } from "node:fs/promises";
+
+//#region src/environment.d.ts
+declare const fs: {
+  stat: typeof stat;
+};
+declare const process: {
+  cwd: () => string;
+};
+//#endregion
+export { fs, process };

package/dist/environment.js

@@ -0,0 +1 @@
+import{stat as e}from"node:fs/promises";import t from"node:process";const n={stat:e},r={cwd:t.cwd.bind(t)};export{n as fs,r as process};

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+import { JsonObject, JsonValue, PrimaryWorkerContributions, PrimaryWorkerEnvironment, WorkerConfig, WorkerDeployEnvironment, WorkerEnvironmentDeclaration, WorkerEnvironmentKind, WorkerEnvironmentVariableConfig, WranglerConfig, coreframeGeneratedWorkerVariables, coreframeLocalWorkerVariables, coreframeManagedWorkerSecrets, derivePrimaryWorkerConfig, normalizeWorkerEnvironment, primaryWorkerConfigPath, primaryWorkerEnvironments, validateWorkerInventoryOwnership, workerBindingNames, wranglerEnvironmentNames } from "./worker.js";
+
+//#region src/index.d.ts
+type CoreframeConfig = {
+  assets?: AssetsConfig;
+  database?: DatabaseConfig;
+  deploy?: DeployConfig;
+  dev?: DevConfig;
+  i18n?: I18nConfig;
+  flutter?: FlutterConfig;
+  worker?: WorkerConfig;
+};
+type FlutterConfig = {
+  deepLink: FlutterDeepLinkConfig;
+};
+type FlutterDeepLinkConfig = {
+  host: string;
+  scheme: string;
+};
+type AssetsConfig = {
+  credentialProfile: string;
+  endpoint: string;
+  projectId: string;
+  publicBaseUrl: string;
+  publicBucket: string;
+  region: string;
+  sourceBucket: string;
+};
+type DatabaseDialect = "postgres" | "sqlite";
+type DatabaseConfig = {
+  dialect: DatabaseDialect;
+  seed?: string;
+};
+type DevPlatform = "android" | "desktop" | "ios" | "macos" | "web" | "webext";
+type DevConfig = {
+  platforms?: DevPlatform[];
+};
+type I18nConfig = {
+  catalogs: string[];
+  directory?: string;
+  generator?: {
+    args?: string[];
+    command: string;
+    id: string;
+  };
+  locales: string[];
+  sourceLocale: string;
+};
+type DeployEnvironment = "staging" | "production";
+type DeployContext = {
+  environment: DeployEnvironment;
+  releaseName: string;
+  url: string;
+  version: string;
+};
+type TauriReleasePlatform = "macos" | "windows" | "linux" | "ios" | "android";
+type TauriReleasePlatformConfig = {
+  artifactGlobs?: string[];
+  buildArgs?: string[];
+  targetTriple?: string;
+  updatePlatform?: string;
+};
+type TauriReleaseConfig = {
+  artifactDownloadDir?: string;
+  b2Bucket?: string;
+  latestManifestPath?: string;
+  localPlatforms?: TauriReleasePlatform[];
+  platform?: Partial<Record<TauriReleasePlatform, TauriReleasePlatformConfig>>;
+  publicBaseUrl?: string;
+  publicPathPrefix?: string;
+  releaseNotesPath?: string;
+  releasePath?: string;
+  releaseUploadDir?: string;
+  workflowPlatforms?: TauriReleasePlatform[];
+  workflowName?: string;
+  workflowPollIntervalMs?: number;
+  workflowRef?: string;
+  workflowTimeoutMs?: number;
+};
+type DeploySmokeCheck = {
+  name: string;
+  path?: string;
+  url?: string;
+  expectedStatus?: "2xx" | number | number[];
+};
+type DeployEnvironmentConfig = {
+  url?: string;
+};
+type StagingHostnameConfig = {
+  managedLabelPrefix: string;
+  parentHostname: string;
+  workerService: string;
+};
+type DeployConfig = {
+  afterDeploy?: (context: DeployContext) => Promise<void> | void;
+  afterWorkerDeploy?: (context: DeployContext) => Promise<void> | void;
+  environments?: Partial<Record<DeployEnvironment, DeployEnvironmentConfig>>;
+  smokeChecks?: DeploySmokeCheck[];
+  stagingHostname?: StagingHostnameConfig;
+  tauriRelease?: TauriReleaseConfig;
+};
+declare function defineConfig(config: CoreframeConfig): CoreframeConfig;
+declare function readProjectConfig({
+  cwd
+}?: {
+  cwd?: string;
+}): Promise<CoreframeConfig>;
+declare function importProjectModule<T>(path: string): Promise<T>;
+declare function importProjectDependency<T>(specifier: string, cwd?: string): Promise<T>;
+//#endregion
+export { AssetsConfig, CoreframeConfig, DatabaseConfig, DatabaseDialect, DeployConfig, DeployContext, DeployEnvironment, DeployEnvironmentConfig, DeploySmokeCheck, DevConfig, DevPlatform, FlutterConfig, FlutterDeepLinkConfig, I18nConfig, JsonObject, JsonValue, PrimaryWorkerContributions, PrimaryWorkerEnvironment, StagingHostnameConfig, TauriReleaseConfig, TauriReleasePlatform, TauriReleasePlatformConfig, WorkerConfig, WorkerDeployEnvironment, WorkerEnvironmentDeclaration, WorkerEnvironmentKind, WorkerEnvironmentVariableConfig, WranglerConfig, coreframeGeneratedWorkerVariables, coreframeLocalWorkerVariables, coreframeManagedWorkerSecrets, defineConfig, derivePrimaryWorkerConfig, importProjectDependency, importProjectModule, normalizeWorkerEnvironment, primaryWorkerConfigPath, primaryWorkerEnvironments, readProjectConfig, validateWorkerInventoryOwnership, workerBindingNames, wranglerEnvironmentNames };

package/dist/index.js

@@ -0,0 +1 @@
+import{fs as e,process as t}from"./environment.js";import{coreframeGeneratedWorkerVariables as n,coreframeLocalWorkerVariables as r,coreframeManagedWorkerSecrets as i,derivePrimaryWorkerConfig as a,normalizeWorkerEnvironment as o,primaryWorkerConfigPath as s,primaryWorkerEnvironments as c,validateWorkerInventoryOwnership as l,workerBindingNames as u,wranglerEnvironmentNames as d}from"./worker.js";import{resolve as f}from"node:path";import{pathToFileURL as p}from"node:url";import{resolve as m}from"import-meta-resolve";function h(e){return e}async function g({cwd:n=t.cwd()}={}){let r=f(n,`coreframe.config.ts`),i;try{i=(await e.stat(r,{bigint:!0})).mtimeNs}catch{return{}}let a=p(r);return a.searchParams.set(`modified`,i.toString()),(await import(a.href)).default??{}}async function _(e){return await import(p(f(t.cwd(),e)).href)}async function v(e,n=t.cwd()){return await import(m(e,p(f(n,`package.json`)).href))}export{n as coreframeGeneratedWorkerVariables,r as coreframeLocalWorkerVariables,i as coreframeManagedWorkerSecrets,h as defineConfig,a as derivePrimaryWorkerConfig,v as importProjectDependency,_ as importProjectModule,o as normalizeWorkerEnvironment,s as primaryWorkerConfigPath,c as primaryWorkerEnvironments,g as readProjectConfig,l as validateWorkerInventoryOwnership,u as workerBindingNames,d as wranglerEnvironmentNames};

package/dist/worker.d.ts

@@ -0,0 +1,46 @@
+//#region src/worker.d.ts
+type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+type JsonObject = {
+  [key: string]: JsonValue;
+};
+declare const primaryWorkerConfigPath = "wrangler.jsonc";
+declare const primaryWorkerEnvironments: readonly ["development", "staging", "production"];
+declare const coreframeGeneratedWorkerVariables: readonly ["DEPLOY_ENV", "POSTHOG_RELEASE"];
+declare const coreframeManagedWorkerSecrets: readonly ["COREFRAME_ACCESS_TOKEN_SECRET", "DASHBOARD_PASSWORD"];
+declare const coreframeLocalWorkerVariables: readonly ["PGDATABASE", "PGHOST", "PGPASSWORD", "PGPORT", "PGUSER", "PORTLESS_URL", "TURSO_AUTH_TOKEN", "TURSO_DATABASE_URL"];
+type PrimaryWorkerEnvironment = (typeof primaryWorkerEnvironments)[number];
+type WorkerDeployEnvironment = Exclude<PrimaryWorkerEnvironment, "development">;
+type WorkerEnvironmentKind = "secret" | "variable" | "generated";
+type WorkerEnvironmentVariableConfig = {
+  description: string;
+  kind: WorkerEnvironmentKind;
+  requiredIn?: WorkerDeployEnvironment[];
+};
+type WorkerConfig = {
+  environment?: Record<string, WorkerEnvironmentVariableConfig>;
+};
+type WorkerEnvironmentDeclaration = WorkerEnvironmentVariableConfig & {
+  name: string;
+  requiredIn: WorkerDeployEnvironment[];
+};
+type WranglerConfig = JsonObject;
+type PrimaryWorkerContributions = {
+  bindings?: JsonObject;
+  generatedValues?: Readonly<Record<string, string>>;
+  requiredSecrets?: readonly string[];
+};
+declare function normalizeWorkerEnvironment(environment: WorkerConfig["environment"]): WorkerEnvironmentDeclaration[];
+declare function derivePrimaryWorkerConfig({
+  config,
+  environment,
+  contributions
+}: {
+  config: WranglerConfig;
+  environment: PrimaryWorkerEnvironment;
+  contributions?: PrimaryWorkerContributions;
+}): WranglerConfig;
+declare function workerBindingNames(config: WranglerConfig): Set<string>;
+declare function wranglerEnvironmentNames(config: WranglerConfig): Set<string>;
+declare function validateWorkerInventoryOwnership(config: WranglerConfig, environment: WorkerConfig["environment"]): void;
+//#endregion
+export { JsonObject, JsonValue, PrimaryWorkerContributions, PrimaryWorkerEnvironment, WorkerConfig, WorkerDeployEnvironment, WorkerEnvironmentDeclaration, WorkerEnvironmentKind, WorkerEnvironmentVariableConfig, WranglerConfig, coreframeGeneratedWorkerVariables, coreframeLocalWorkerVariables, coreframeManagedWorkerSecrets, derivePrimaryWorkerConfig, normalizeWorkerEnvironment, primaryWorkerConfigPath, primaryWorkerEnvironments, validateWorkerInventoryOwnership, workerBindingNames, wranglerEnvironmentNames };

package/dist/worker.js

@@ -0,0 +1 @@
+const e=`wrangler.jsonc`,t=[`development`,`staging`,`production`],n=[`DEPLOY_ENV`,`POSTHOG_RELEASE`],r=[`COREFRAME_ACCESS_TOKEN_SECRET`,`DASHBOARD_PASSWORD`],i=[`PGDATABASE`,`PGHOST`,`PGPASSWORD`,`PGPORT`,`PGUSER`,`PORTLESS_URL`,`TURSO_AUTH_TOKEN`,`TURSO_DATABASE_URL`],a=/^[A-Z][A-Z0-9_]*$/;function o(e){return Object.entries(e??{}).map(([e,t])=>{if(!a.test(e))throw Error(`Invalid Worker environment name ${JSON.stringify(e)} in coreframe.config.ts. Use uppercase letters, numbers, and underscores.`);let r=[...new Set(t.requiredIn??[])];if(t.kind===`generated`&&!n.includes(e))throw Error(`${e} is declared as generated, but Coreframe does not generate it. Use kind "variable" or "secret".`);if(n.includes(e)&&t.kind!==`generated`)throw Error(`${e} is generated by Coreframe and must use kind "generated".`);return{...t,name:e,requiredIn:r}}).sort((e,t)=>e.name.localeCompare(t.name))}function s({config:e,environment:t,contributions:n={}}){let r=structuredClone(e),i=m(r.env,`env`),a=m(i[t],`env.${t}`),o=m(a.vars,`env.${t}.vars`),s=m(a.secrets,`env.${t}.secrets`),c=h(s.required,`env.${t}.secrets.required`),l=n.generatedValues??{},u=[...new Set(n.requiredSecrets??[])].sort();f(`variable`,Object.keys(o),Object.keys(l),t),f(`secret`,c,u,t);let g=n.bindings??{},{env:_,...v}=r,y=p(v,a),b=p(g);f(`binding`,[...y],[...b],t);let x=d(a,g,`env.${t}`);return Object.keys(l).length>0&&(x.vars={...o,...l}),u.length>0&&(x.secrets={...s,required:[...c,...u].sort()}),r.env={...i,[t]:x},r}function c(e){return p(e)}function l(e){let t=p(e),n=e=>{if(!g(e))return;let n=g(e.vars)?e.vars:{};Object.keys(n).forEach(e=>t.add(e));let r=g(e.secrets)?e.secrets:{};(Array.isArray(r.required)?r.required:[]).forEach(e=>{typeof e==`string`&&t.add(e)})};return n(e),g(e.env)&&Object.values(e.env).forEach(n),t}function u(e,t){let n=o(t),r=new Map(n.map(e=>[e.name,e])),i=[...p(e)].filter(e=>r.has(e)).sort(),a=new Set,s=new Set,c=e=>{g(e)&&(g(e.vars)&&Object.keys(e.vars).forEach(e=>{r.get(e)?.kind===`secret`&&a.add(e)}),g(e.secrets)&&Array.isArray(e.secrets.required)&&e.secrets.required.forEach(e=>{typeof e==`string`&&r.get(e)?.kind!==`secret`&&r.has(e)&&s.add(e)}))};c(e),g(e.env)&&Object.values(e.env).forEach(c);let l=[...i.map(e=>`${e} (native binding)`),...[...a].sort().map(e=>`${e} (plain variable)`),...[...s].sort().map(e=>`${e} (required secret)`)];if(l.length>0)throw Error(`Worker inventory ownership conflicts with wrangler.jsonc: ${l.join(`, `)}. Keep string metadata in coreframe.config.ts and native binding topology in wrangler.jsonc.`)}function d(e,t,n){let r={...e};for(let[i,a]of Object.entries(t)){if(i in e)throw Error(`Coreframe cannot contribute ${n}.${i}; wrangler.jsonc already owns it.`);r[i]=structuredClone(a)}return r}function f(e,t,n,r){let i=n.filter(e=>t.includes(e)).sort();if(i.length>0)throw Error(`Coreframe ${e} ownership conflicts in Wrangler environment ${r}: ${i.join(`, `)}. Remove the duplicate declarations from wrangler.jsonc.`)}function p(...e){let t=new Set,n=e=>{if(Array.isArray(e)){e.forEach(n);return}g(e)&&(typeof e.binding==`string`&&t.add(e.binding),Object.values(e).forEach(n))};return e.forEach(n),t}function m(e,t){if(e===void 0)return{};if(!g(e))throw Error(`${t} in wrangler.jsonc must be an object.`);return e}function h(e,t){if(e===void 0)return[];if(!Array.isArray(e)||!e.every(e=>typeof e==`string`))throw Error(`${t} in wrangler.jsonc must be an array of strings.`);return e}function g(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{n as coreframeGeneratedWorkerVariables,i as coreframeLocalWorkerVariables,r as coreframeManagedWorkerSecrets,s as derivePrimaryWorkerConfig,o as normalizeWorkerEnvironment,e as primaryWorkerConfigPath,t as primaryWorkerEnvironments,u as validateWorkerInventoryOwnership,c as workerBindingNames,l as wranglerEnvironmentNames};

package/package.json

@@ -1,13 +1,36 @@
 {
   "name": "@coreframe/config",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/airlock-labs/coreframe.git",
+    "directory": "node/config"
+  },
+  "files": [
+    "dist/"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "import-meta-resolve": "^4.2.0"
   },
-  "keywords": [],
-  "author": "",
-  "license": "All rights reserved",
-  "type": "commonjs"
-}
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --reporter=minimal",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "format": "oxlint --fix && oxfmt",
+    "lint": "oxlint"
+  }
+}

package/readme.md

@@ -1 +0,0 @@
-Coming soon...