@willbooster/wb 22.10.0 → 22.11.1

package/README.md

@@ -20,11 +20,14 @@ Commands:
                                  environments with this command to fail fast on
                                  missing secrets.
   wb concurrently <commands...>  Run commands concurrently
-  wb deploy                      Deploy a Cloudflare Workers app (vinext or
-                                 plain Worker) to the WB_ENV environment:
-                                 validate secrets, build, apply remote D1
-                                 migrations, then deploy code and secrets
-                                 atomically.
+  wb deploy                      Deploy to the WB_ENV environment. A Cloudflare
+                                 Workers app (vinext or plain Worker): validate
+                                 secrets, build, apply remote D1 migrations,
+                                 then deploy code and secrets atomically. A
+                                 Railway service (.railway/railway.ts): check
+                                 the IaC plan, sync fnox variables, apply the
+                                 plan, then railway up; --dry-run only checks
+                                 the plan of every environment.
   wb dotenv [args..]             Load environment variables from fnox and run a
                                  command.
   wb gen-code                    Generate code for the current project

package/bin/railway.d.ts

@@ -0,0 +1,4 @@
+export function railwayVariables<T, V = string>(
+  preserve: () => T,
+  railwayOnlyVariables?: Record<string, V>
+): Record<string, T | V>;

package/bin/railway.js

@@ -0,0 +1,30 @@
+/**
+ * Build the `env` of a Railway service in `.railway/railway.ts`, evaluated through `wb deploy`.
+ * Call it inside the default-exported function that only the Railway CLI evaluates (e.g. the callback
+ * of `railway/iac`'s `defineRailway`), never at module scope: `wb` imports the file for
+ * `railwayTarget` before it passes the variable names.
+ *
+ * Every variable `wb deploy` syncs from fnox is declared with `preserve()`, so Railway keeps the
+ * value `wb deploy` pushed and plans a deletion for any variable neither here nor in fnox.
+ * `railwayOnlyVariables` adds values Railway supplies: literals that only Railway reads, or
+ * `railway/iac` references such as a linked database's `DATABASE_URL`. Such a key must not be
+ * exported by the deployed fnox profile (e.g. `KEY = { env = false }` in its profile table).
+ *
+ * @param {() => unknown} preserve `preserve` from `railway/iac`.
+ * @param {Record<string, unknown>} [railwayOnlyVariables]
+ * @returns {Record<string, unknown>}
+ */
+export function railwayVariables(preserve, railwayOnlyVariables = {}) {
+  const namesJson = process.env.WB_RAILWAY_VARIABLE_NAMES;
+  if (namesJson === undefined) {
+    throw new Error(
+      'railwayVariables() needs the fnox variable names that `wb deploy` passes to the Railway CLI: call it inside the default-exported function (e.g. the callback of defineRailway), not at module scope, and plan through `wb deploy`.'
+    );
+  }
+  const names = JSON.parse(namesJson);
+  const duplicatedNames = names.filter((name) => Object.hasOwn(railwayOnlyVariables, name));
+  if (duplicatedNames.length > 0) {
+    throw new Error(`Declare each variable in either fnox or railway.ts, not both: ${duplicatedNames.join(', ')}`);
+  }
+  return { ...Object.fromEntries(names.map((name) => [name, preserve()])), ...railwayOnlyVariables };
+}

package/dist/error-CBsvD8TI.js

@@ -0,0 +1,2 @@
+function e(e,t){return n(()=>e instanceof Error?e.message:t??String(e))??t??n(()=>Object.prototype.toString.call(e))??`Unknown error`}function t(e,t){return typeof e==`object`&&!!e&&`code`in e&&e.code===t}function n(e){try{return e()}catch{}}async function r(e){try{return await e()}catch(e){if(t(e,`ENOENT`))return;throw e}}export{t as n,r,e as t};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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