nymbal 1.3.0 → 1.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.js +1241 -208
- package/dist/index.js.map +1 -1
- package/package.json +8 -7
package/dist/index.js
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
// src/index.ts
|
|
2
|
-
import { defineCommand as
|
|
2
|
+
import { defineCommand as defineCommand17, runMain, showUsage } from "citty";
|
|
3
3
|
|
|
4
4
|
// src/utils/version.ts
|
|
5
5
|
import { readFileSync } from "fs";
|
|
@@ -30,6 +30,7 @@ import { resolve as resolve4 } from "path";
|
|
|
30
30
|
import { defineCommand as defineCommand2 } from "citty";
|
|
31
31
|
import pc from "picocolors";
|
|
32
32
|
import { KNOWN_PROVIDERS } from "@nymbalhq/config";
|
|
33
|
+
import { ConfigError } from "@nymbalhq/types";
|
|
33
34
|
|
|
34
35
|
// src/utils/project.ts
|
|
35
36
|
import { existsSync } from "fs";
|
|
@@ -56,9 +57,9 @@ function run(command, args, options = {}) {
|
|
|
56
57
|
shell: false,
|
|
57
58
|
...options
|
|
58
59
|
});
|
|
59
|
-
const done = new Promise((
|
|
60
|
+
const done = new Promise((resolve11, reject) => {
|
|
60
61
|
child2.on("error", reject);
|
|
61
|
-
child2.on("exit", (code) =>
|
|
62
|
+
child2.on("exit", (code) => resolve11(code ?? 0));
|
|
62
63
|
});
|
|
63
64
|
return { child: child2, done };
|
|
64
65
|
}
|
|
@@ -73,16 +74,16 @@ async function runOrFail(command, args, options = {}) {
|
|
|
73
74
|
// src/utils/port.ts
|
|
74
75
|
import { createServer } from "net";
|
|
75
76
|
async function isPortFree(port, host) {
|
|
76
|
-
return new Promise((
|
|
77
|
+
return new Promise((resolve11) => {
|
|
77
78
|
const server = createServer();
|
|
78
79
|
server.once("error", (err2) => {
|
|
79
80
|
if (err2.code !== "EADDRINUSE" && err2.code !== "EACCES") {
|
|
80
81
|
console.error(`[dev] unexpected error probing port ${port}:`, err2.message);
|
|
81
82
|
}
|
|
82
|
-
|
|
83
|
+
resolve11(false);
|
|
83
84
|
});
|
|
84
85
|
server.once("listening", () => {
|
|
85
|
-
server.close(() =>
|
|
86
|
+
server.close(() => resolve11(true));
|
|
86
87
|
});
|
|
87
88
|
if (host) {
|
|
88
89
|
server.listen(port, host);
|
|
@@ -243,8 +244,8 @@ async function runShutdown(steps, opts) {
|
|
|
243
244
|
pending = void 0;
|
|
244
245
|
})();
|
|
245
246
|
let timer;
|
|
246
|
-
const bound = new Promise((
|
|
247
|
-
timer = setTimeout(() =>
|
|
247
|
+
const bound = new Promise((resolve11) => {
|
|
248
|
+
timer = setTimeout(() => resolve11("bound"), opts.boundMs);
|
|
248
249
|
});
|
|
249
250
|
const outcome = await Promise.race([work.then(() => "done"), bound]);
|
|
250
251
|
clearTimeout(timer);
|
|
@@ -259,6 +260,7 @@ async function runShutdown(steps, opts) {
|
|
|
259
260
|
}
|
|
260
261
|
|
|
261
262
|
// src/commands/dev-summary.ts
|
|
263
|
+
import { slotFolder } from "@nymbalhq/config";
|
|
262
264
|
import { displayUrl } from "@nymbalhq/types";
|
|
263
265
|
var WIDTH = 100;
|
|
264
266
|
var LABEL = 14;
|
|
@@ -307,7 +309,7 @@ function renderDevSummary(info) {
|
|
|
307
309
|
"",
|
|
308
310
|
...slotLines,
|
|
309
311
|
"",
|
|
310
|
-
...info.primitives.map(({ name, provider }) => row(name, provider)),
|
|
312
|
+
...info.primitives.map(({ name, provider }) => row(slotFolder(name), provider)),
|
|
311
313
|
"",
|
|
312
314
|
" Debug logs: run with --verbose (or LOG_LEVEL=debug)."
|
|
313
315
|
];
|
|
@@ -426,6 +428,11 @@ var devCommand = defineCommand2({
|
|
|
426
428
|
version,
|
|
427
429
|
logger,
|
|
428
430
|
...loaded.adapters !== void 0 && { adapters: loaded.adapters }
|
|
431
|
+
}).catch((error) => {
|
|
432
|
+
if (!(error instanceof ConfigError)) throw error;
|
|
433
|
+
process.stderr.write(`${pc.red(error.message)}
|
|
434
|
+
`);
|
|
435
|
+
process.exit(1);
|
|
429
436
|
});
|
|
430
437
|
const { platform } = app;
|
|
431
438
|
if (args.seed) {
|
|
@@ -522,11 +529,93 @@ var devCommand = defineCommand2({
|
|
|
522
529
|
});
|
|
523
530
|
|
|
524
531
|
// src/commands/build.ts
|
|
532
|
+
import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync } from "fs";
|
|
533
|
+
import { join as join3 } from "path";
|
|
525
534
|
import { defineCommand as defineCommand3 } from "citty";
|
|
535
|
+
|
|
536
|
+
// src/deploy/dockerfile.ts
|
|
537
|
+
var FROZEN_INSTALL = {
|
|
538
|
+
npm: "npm ci",
|
|
539
|
+
pnpm: "pnpm install --frozen-lockfile",
|
|
540
|
+
yarn: "yarn install --immutable",
|
|
541
|
+
bun: "bun install --frozen-lockfile"
|
|
542
|
+
};
|
|
543
|
+
function parsePackageManager(packageManager) {
|
|
544
|
+
const match = /^(npm|pnpm|yarn|bun)@(\d+\.\d+\.\d+[^\s+]*)/.exec(packageManager.trim());
|
|
545
|
+
if (!match) {
|
|
546
|
+
throw new Error(
|
|
547
|
+
`package.json "packageManager" must be npm, pnpm, yarn or bun at a version, such as "pnpm@10.18.0"`
|
|
548
|
+
);
|
|
549
|
+
}
|
|
550
|
+
return { name: match[1], version: match[2] };
|
|
551
|
+
}
|
|
552
|
+
function renderDockerfile(options) {
|
|
553
|
+
const { name, version } = parsePackageManager(options.packageManager);
|
|
554
|
+
const manager = name === "bun" ? `RUN npm install -g bun@${version}` : "RUN npm install -g corepack@0.36.0 && corepack enable";
|
|
555
|
+
const berry = name === "yarn" && Number(version.split(".")[0]) >= 2;
|
|
556
|
+
return [
|
|
557
|
+
`ARG NODE_VERSION=${options.nodeVersion}`,
|
|
558
|
+
"",
|
|
559
|
+
"FROM node:${NODE_VERSION}-slim AS build",
|
|
560
|
+
"ENV COREPACK_ENABLE_DOWNLOAD_PROMPT=0",
|
|
561
|
+
"WORKDIR /app",
|
|
562
|
+
// better-sqlite3 compiles from source when its prebuilt binary cannot be fetched for this Node and platform.
|
|
563
|
+
"RUN apt-get update && apt-get install -y --no-install-recommends python3 make g++ && rm -rf /var/lib/apt/lists/*",
|
|
564
|
+
manager,
|
|
565
|
+
"COPY . .",
|
|
566
|
+
...berry ? [
|
|
567
|
+
"RUN grep -q '^nodeLinker:' .yarnrc.yml 2>/dev/null || echo 'nodeLinker: node-modules' >> .yarnrc.yml"
|
|
568
|
+
] : [],
|
|
569
|
+
`RUN ${FROZEN_INSTALL[name]}`,
|
|
570
|
+
// An empty public API URL: the browser calls the origin that served the page.
|
|
571
|
+
"RUN PUBLIC_NYMBAL_API_URL= NEXT_PUBLIC_NYMBAL_API_URL= node node_modules/nymbal/bin/nymbal.mjs build",
|
|
572
|
+
"",
|
|
573
|
+
"FROM node:${NODE_VERSION}-slim",
|
|
574
|
+
"ENV NODE_ENV=production",
|
|
575
|
+
"WORKDIR /app",
|
|
576
|
+
"COPY --from=build --chown=node:node /app /app",
|
|
577
|
+
"USER node",
|
|
578
|
+
"EXPOSE 3001",
|
|
579
|
+
'CMD ["node", "node_modules/nymbal/bin/nymbal.mjs", "start"]',
|
|
580
|
+
""
|
|
581
|
+
].join("\n");
|
|
582
|
+
}
|
|
583
|
+
var DOCKERIGNORE = [
|
|
584
|
+
".env*",
|
|
585
|
+
"**/.env*",
|
|
586
|
+
"*.db",
|
|
587
|
+
"*.db-*",
|
|
588
|
+
"**/*.db",
|
|
589
|
+
"**/*.db-*",
|
|
590
|
+
"node_modules",
|
|
591
|
+
"**/node_modules",
|
|
592
|
+
"dist",
|
|
593
|
+
".astro",
|
|
594
|
+
".next",
|
|
595
|
+
".git",
|
|
596
|
+
""
|
|
597
|
+
].join("\n");
|
|
598
|
+
|
|
599
|
+
// src/commands/build.ts
|
|
526
600
|
var buildCommand = defineCommand3({
|
|
527
601
|
meta: { name: "build", description: "Production build of the configured template" },
|
|
528
|
-
|
|
602
|
+
args: {
|
|
603
|
+
image: {
|
|
604
|
+
type: "boolean",
|
|
605
|
+
description: "Build a container image of the store (writes a Dockerfile when absent)",
|
|
606
|
+
default: false
|
|
607
|
+
},
|
|
608
|
+
tag: {
|
|
609
|
+
type: "string",
|
|
610
|
+
description: "The image name (default: <package name>:latest)"
|
|
611
|
+
}
|
|
612
|
+
},
|
|
613
|
+
async run({ args }) {
|
|
529
614
|
const { config, projectRoot } = await loadProject();
|
|
615
|
+
if (args.image) {
|
|
616
|
+
await buildImage(projectRoot, config.template, args.tag, args._);
|
|
617
|
+
return;
|
|
618
|
+
}
|
|
530
619
|
if (!isFlatScaffold(projectRoot, config.template)) {
|
|
531
620
|
await runOrFail("pnpm", ["--filter", templateFilterFor(config.template), "build"], {
|
|
532
621
|
cwd: projectRoot
|
|
@@ -543,11 +632,617 @@ var buildCommand = defineCommand3({
|
|
|
543
632
|
await runOrFail(bin, ["build"], { cwd: projectRoot });
|
|
544
633
|
}
|
|
545
634
|
});
|
|
635
|
+
async function buildImage(root, template, tag, dockerArgs) {
|
|
636
|
+
const pkg = JSON.parse(readFileSync2(join3(root, "package.json"), "utf8"));
|
|
637
|
+
const dockerfile = join3(root, "Dockerfile");
|
|
638
|
+
if (existsSync5(dockerfile)) {
|
|
639
|
+
console.log("Using the Dockerfile already in the project, as it is");
|
|
640
|
+
} else {
|
|
641
|
+
if (pkg.packageManager === void 0) {
|
|
642
|
+
throw new Error(
|
|
643
|
+
'package.json records no "packageManager" (such as "pnpm@10.18.0"), so the image cannot install as the project does'
|
|
644
|
+
);
|
|
645
|
+
}
|
|
646
|
+
const nodeVersionFile = join3(root, ".node-version");
|
|
647
|
+
const nodeVersion = existsSync5(nodeVersionFile) ? readFileSync2(nodeVersionFile, "utf8").trim().replace(/^v/, "") : process.versions.node;
|
|
648
|
+
writeFileSync(
|
|
649
|
+
dockerfile,
|
|
650
|
+
renderDockerfile({ packageManager: pkg.packageManager, nodeVersion, template })
|
|
651
|
+
);
|
|
652
|
+
console.log("\u2713 wrote Dockerfile");
|
|
653
|
+
}
|
|
654
|
+
const ignore = join3(root, ".dockerignore");
|
|
655
|
+
if (!existsSync5(ignore)) {
|
|
656
|
+
writeFileSync(ignore, DOCKERIGNORE);
|
|
657
|
+
console.log("\u2713 wrote .dockerignore");
|
|
658
|
+
}
|
|
659
|
+
const name = tag ?? `${(pkg.name ?? "store").replace(/^@/, "").replace(/\//g, "-")}:latest`;
|
|
660
|
+
await runOrFail("docker", ["build", "-t", name, ...dockerArgs, "."], { cwd: root });
|
|
661
|
+
}
|
|
546
662
|
|
|
547
|
-
// src/commands/
|
|
663
|
+
// src/commands/start.ts
|
|
664
|
+
import { spawn as spawn2 } from "child_process";
|
|
665
|
+
import { existsSync as existsSync6 } from "fs";
|
|
666
|
+
import { createRequire as createRequire2 } from "module";
|
|
667
|
+
import { connect, createServer as createServer2 } from "net";
|
|
668
|
+
import { join as join4, resolve as resolve5 } from "path";
|
|
548
669
|
import { defineCommand as defineCommand4 } from "citty";
|
|
549
|
-
import
|
|
550
|
-
|
|
670
|
+
import pc2 from "picocolors";
|
|
671
|
+
import { boundedHealthCheck, ConfigError as ConfigError2 } from "@nymbalhq/types";
|
|
672
|
+
import {
|
|
673
|
+
createApp as createApp2,
|
|
674
|
+
createCommandStore as createCommandStore2,
|
|
675
|
+
createLogger as createLogger2,
|
|
676
|
+
keyProblem,
|
|
677
|
+
migrationState,
|
|
678
|
+
readSecretsKey,
|
|
679
|
+
resolveAuthSecret,
|
|
680
|
+
runMigrations as runMigrations2
|
|
681
|
+
} from "@nymbalhq/platform";
|
|
682
|
+
import {
|
|
683
|
+
createHttpServer as createHttpServer2,
|
|
684
|
+
createReadyRoute,
|
|
685
|
+
FastifyHttpAdapter,
|
|
686
|
+
forwardToStorefront,
|
|
687
|
+
resolveTrustProxy
|
|
688
|
+
} from "@nymbalhq/http";
|
|
689
|
+
var DEFAULT_PORT = 3001;
|
|
690
|
+
var DEFAULT_SHUTDOWN_MS = 1e4;
|
|
691
|
+
var STOREFRONT_START_MS = 6e4;
|
|
692
|
+
function publicOrigin(value) {
|
|
693
|
+
if (value === void 0 || value.trim() === "") return null;
|
|
694
|
+
try {
|
|
695
|
+
const url = new URL(value.trim());
|
|
696
|
+
const plain = (url.protocol === "http:" || url.protocol === "https:") && url.pathname === "/" && url.search === "" && url.hash === "" && url.username === "" && url.password === "";
|
|
697
|
+
return plain ? url.origin : null;
|
|
698
|
+
} catch {
|
|
699
|
+
return null;
|
|
700
|
+
}
|
|
701
|
+
}
|
|
702
|
+
function checkStartEnv(config, env) {
|
|
703
|
+
const problems = [];
|
|
704
|
+
const isSet2 = (name) => (env[name] ?? "").trim() !== "";
|
|
705
|
+
const infra = config.infrastructure;
|
|
706
|
+
if (infra.commandStore === "postgres" && !isSet2("DATABASE_URL")) {
|
|
707
|
+
problems.push("DATABASE_URL is not set: the postgres command store connects with it");
|
|
708
|
+
}
|
|
709
|
+
const onRedis = infra.documentStore.provider === "redis" || infra.eventBus.provider === "redis-streams";
|
|
710
|
+
if (onRedis && infra.redis?.url === void 0 && !isSet2("REDIS_URL")) {
|
|
711
|
+
problems.push(
|
|
712
|
+
"REDIS_URL is not set: the Redis document store and event bus connect with it (or set infrastructure.redis.url)"
|
|
713
|
+
);
|
|
714
|
+
}
|
|
715
|
+
const key = readSecretsKey(env);
|
|
716
|
+
if (!key.ok) {
|
|
717
|
+
problems.push(`${keyProblem(key.reason)}: settings are encrypted with it`);
|
|
718
|
+
}
|
|
719
|
+
if (!isSet2("NYMBAL_PUBLIC_URL")) {
|
|
720
|
+
problems.push("NYMBAL_PUBLIC_URL is not set: give the store's public origin, such as https://\u2026");
|
|
721
|
+
} else if (publicOrigin(env["NYMBAL_PUBLIC_URL"]) === null) {
|
|
722
|
+
problems.push("NYMBAL_PUBLIC_URL must be an http or https origin with no path");
|
|
723
|
+
}
|
|
724
|
+
const refusal = (check) => {
|
|
725
|
+
try {
|
|
726
|
+
return check();
|
|
727
|
+
} catch (error) {
|
|
728
|
+
if (!(error instanceof ConfigError2)) throw error;
|
|
729
|
+
problems.push(error.message);
|
|
730
|
+
return void 0;
|
|
731
|
+
}
|
|
732
|
+
};
|
|
733
|
+
const jwt = refusal(() => resolveAuthSecret(config, env));
|
|
734
|
+
refusal(() => resolveTrustProxy(config, env));
|
|
735
|
+
if (env["NODE_ENV"] === "development") {
|
|
736
|
+
problems.push("NODE_ENV is development: nymbal start runs in production; unset it");
|
|
737
|
+
}
|
|
738
|
+
if (env["NODE_ENV"] === "production") {
|
|
739
|
+
if (config.commerce.payments.provider === "native") {
|
|
740
|
+
problems.push(
|
|
741
|
+
"commerce.payments.provider is native, the stub that verifies no webhook signature (config.production_stub_payments): configure a real payments provider, such as `nymbal add stripe`"
|
|
742
|
+
);
|
|
743
|
+
}
|
|
744
|
+
if (jwt?.source === "default") {
|
|
745
|
+
problems.push(
|
|
746
|
+
"security.auth.jwtSecret is the schema default (config.production_default_jwt_secret): set NYMBAL_JWT_SECRET (create-nymbal-app writes one into .env) or a secret of your own in nymbal.config.ts"
|
|
747
|
+
);
|
|
748
|
+
}
|
|
749
|
+
}
|
|
750
|
+
return problems;
|
|
751
|
+
}
|
|
752
|
+
var STOREFRONT_NYMBAL_ENV = /* @__PURE__ */ new Set([
|
|
753
|
+
"NYMBAL_API_URL",
|
|
754
|
+
"NYMBAL_PUBLIC_URL",
|
|
755
|
+
"NYMBAL_CATALOG_REVALIDATE_S",
|
|
756
|
+
"NYMBAL_NEXT_DIST_DIR"
|
|
757
|
+
]);
|
|
758
|
+
function storefrontEnv2(env) {
|
|
759
|
+
return Object.fromEntries(
|
|
760
|
+
Object.entries(env).filter(
|
|
761
|
+
([name]) => name !== "DATABASE_URL" && name !== "REDIS_URL" && (!name.startsWith("NYMBAL_") || STOREFRONT_NYMBAL_ENV.has(name))
|
|
762
|
+
)
|
|
763
|
+
);
|
|
764
|
+
}
|
|
765
|
+
function fail(lines) {
|
|
766
|
+
for (const line of lines) process.stderr.write(`${pc2.red(line)}
|
|
767
|
+
`);
|
|
768
|
+
process.exit(1);
|
|
769
|
+
}
|
|
770
|
+
function publicPort(flag2, env) {
|
|
771
|
+
const given = flag2 !== void 0 && flag2.trim() !== "" ? flag2 : env["PORT"];
|
|
772
|
+
if (given === void 0 || given.trim() === "") return DEFAULT_PORT;
|
|
773
|
+
const port = Number(given);
|
|
774
|
+
if (!Number.isInteger(port) || port < 1 || port > 65535) {
|
|
775
|
+
fail([`The port must be an integer from 1 to 65535, got "${given}"`]);
|
|
776
|
+
}
|
|
777
|
+
return port;
|
|
778
|
+
}
|
|
779
|
+
function shutdownBound(env) {
|
|
780
|
+
const ms = Number(env["NYMBAL_SHUTDOWN_MS"]);
|
|
781
|
+
return Number.isInteger(ms) && ms > 0 ? ms : DEFAULT_SHUTDOWN_MS;
|
|
782
|
+
}
|
|
783
|
+
function storefrontLaunch(root, template, env) {
|
|
784
|
+
const entry = env["NYMBAL_STOREFRONT_ENTRY"];
|
|
785
|
+
if (entry !== void 0 && entry.trim() !== "") {
|
|
786
|
+
const file = resolve5(root, entry);
|
|
787
|
+
return () => [file];
|
|
788
|
+
}
|
|
789
|
+
if (template === "astro") {
|
|
790
|
+
const file = join4(root, "dist", "server", "entry.mjs");
|
|
791
|
+
if (!existsSync6(file)) return "The storefront is not built: run `nymbal build` first";
|
|
792
|
+
return () => [file];
|
|
793
|
+
}
|
|
794
|
+
if (!existsSync6(join4(root, ".next", "BUILD_ID"))) {
|
|
795
|
+
return "The storefront is not built: run `nymbal build` first";
|
|
796
|
+
}
|
|
797
|
+
const next = createRequire2(join4(root, "package.json")).resolve("next/dist/bin/next");
|
|
798
|
+
return (port) => [next, "start", "-H", "127.0.0.1", "-p", String(port)];
|
|
799
|
+
}
|
|
800
|
+
async function migrationGate(config, migrationsRoot, apply) {
|
|
801
|
+
const store = createCommandStore2(config);
|
|
802
|
+
try {
|
|
803
|
+
const { pending } = await migrationState(store, { migrationsRoot });
|
|
804
|
+
if (pending === 0) return;
|
|
805
|
+
if (!apply) {
|
|
806
|
+
fail([
|
|
807
|
+
`${pending} migration${pending === 1 ? "" : "s"} pending: run \`nymbal migrate\` (a deploy's release step does), or \`nymbal start --migrate\` on a single host`
|
|
808
|
+
]);
|
|
809
|
+
}
|
|
810
|
+
await runMigrations2(store, { migrationsRoot });
|
|
811
|
+
} finally {
|
|
812
|
+
await store.close();
|
|
813
|
+
}
|
|
814
|
+
}
|
|
815
|
+
function loopbackPort() {
|
|
816
|
+
return new Promise((resolvePort, reject) => {
|
|
817
|
+
const server = createServer2();
|
|
818
|
+
server.once("error", reject);
|
|
819
|
+
server.listen(0, "127.0.0.1", () => {
|
|
820
|
+
const { port } = server.address();
|
|
821
|
+
server.close(() => resolvePort(port));
|
|
822
|
+
});
|
|
823
|
+
});
|
|
824
|
+
}
|
|
825
|
+
async function listening(port, gone, withinMs) {
|
|
826
|
+
let exited = false;
|
|
827
|
+
void gone.then(() => exited = true);
|
|
828
|
+
const deadline = Date.now() + withinMs;
|
|
829
|
+
while (!exited && Date.now() < deadline) {
|
|
830
|
+
const open = await new Promise((resolveOpen) => {
|
|
831
|
+
const socket = connect(port, "127.0.0.1");
|
|
832
|
+
socket.once("connect", () => {
|
|
833
|
+
socket.destroy();
|
|
834
|
+
resolveOpen(true);
|
|
835
|
+
});
|
|
836
|
+
socket.once("error", () => resolveOpen(false));
|
|
837
|
+
});
|
|
838
|
+
if (open) return true;
|
|
839
|
+
await new Promise((r) => setTimeout(r, 100));
|
|
840
|
+
}
|
|
841
|
+
return false;
|
|
842
|
+
}
|
|
843
|
+
async function commandStoreReport(store, migrationsRoot) {
|
|
844
|
+
const { pending } = await migrationState(store, { migrationsRoot });
|
|
845
|
+
return { status: pending === 0 ? "healthy" : "down" };
|
|
846
|
+
}
|
|
847
|
+
var startCommand = defineCommand4({
|
|
848
|
+
meta: {
|
|
849
|
+
name: "start",
|
|
850
|
+
description: "Run the built store in production: the API, the admin and the storefront on one port"
|
|
851
|
+
},
|
|
852
|
+
args: {
|
|
853
|
+
migrate: {
|
|
854
|
+
type: "boolean",
|
|
855
|
+
description: "Apply pending migrations first (a single host; a deploy runs `nymbal migrate`)",
|
|
856
|
+
default: false
|
|
857
|
+
},
|
|
858
|
+
port: {
|
|
859
|
+
type: "string",
|
|
860
|
+
description: "The public port (default: PORT, else 3001)"
|
|
861
|
+
}
|
|
862
|
+
},
|
|
863
|
+
async run({ args }) {
|
|
864
|
+
let child2 = null;
|
|
865
|
+
const childAlive = () => child2 !== null && child2.exitCode === null && child2.signalCode === null;
|
|
866
|
+
const stopBoot = () => {
|
|
867
|
+
if (childAlive()) child2.kill("SIGKILL");
|
|
868
|
+
process.exit(1);
|
|
869
|
+
};
|
|
870
|
+
process.on("SIGTERM", stopBoot);
|
|
871
|
+
process.on("SIGINT", stopBoot);
|
|
872
|
+
const loaded = await loadProject().catch(
|
|
873
|
+
(error) => fail([error instanceof Error ? error.message : String(error)])
|
|
874
|
+
);
|
|
875
|
+
const { projectRoot } = loaded;
|
|
876
|
+
if ((process.env["NODE_ENV"] ?? "") === "") process.env["NODE_ENV"] = "production";
|
|
877
|
+
const problems = checkStartEnv(loaded.config, process.env);
|
|
878
|
+
if (problems.length > 0) fail(problems);
|
|
879
|
+
const port = publicPort(args.port, process.env);
|
|
880
|
+
const publicUrl = publicOrigin(process.env["NYMBAL_PUBLIC_URL"]);
|
|
881
|
+
const launch = storefrontLaunch(projectRoot, loaded.config.template, process.env);
|
|
882
|
+
if (typeof launch === "string") fail([launch]);
|
|
883
|
+
const config = {
|
|
884
|
+
...loaded.config,
|
|
885
|
+
http: {
|
|
886
|
+
...loaded.config.http,
|
|
887
|
+
port,
|
|
888
|
+
// The store's own pages subscribe to alerts and call the API from this origin.
|
|
889
|
+
cors: {
|
|
890
|
+
...loaded.config.http.cors,
|
|
891
|
+
allowedOrigins: [.../* @__PURE__ */ new Set([...loaded.config.http.cors.allowedOrigins, publicUrl])]
|
|
892
|
+
}
|
|
893
|
+
}
|
|
894
|
+
};
|
|
895
|
+
const migrationsRoot = resolveMigrations(projectRoot);
|
|
896
|
+
await migrationGate(config, migrationsRoot, args.migrate);
|
|
897
|
+
const version = getCliVersion();
|
|
898
|
+
const logger = createLogger2({
|
|
899
|
+
base: { store: config.store.name },
|
|
900
|
+
level: process.env["LOG_LEVEL"] || "info"
|
|
901
|
+
});
|
|
902
|
+
const app = await createApp2(config, {
|
|
903
|
+
version,
|
|
904
|
+
logger,
|
|
905
|
+
...loaded.adapters !== void 0 && { adapters: loaded.adapters }
|
|
906
|
+
}).catch((error) => {
|
|
907
|
+
if (!(error instanceof ConfigError2)) throw error;
|
|
908
|
+
return fail([error.message]);
|
|
909
|
+
});
|
|
910
|
+
const { platform } = app;
|
|
911
|
+
let stopping = false;
|
|
912
|
+
const downAs = async (name, check) => (await boundedHealthCheck(check)).status === "down" ? name : null;
|
|
913
|
+
const probe = async () => {
|
|
914
|
+
if (stopping) return { ready: false, failing: [] };
|
|
915
|
+
const down = (await Promise.all([
|
|
916
|
+
downAs("command-store", () => commandStoreReport(platform.commandStore, migrationsRoot)),
|
|
917
|
+
downAs(
|
|
918
|
+
"document-store",
|
|
919
|
+
() => platform.documentStore.healthCheck?.() ?? { status: "degraded" }
|
|
920
|
+
),
|
|
921
|
+
downAs("event-bus", () => platform.eventBus.healthCheck?.() ?? { status: "degraded" })
|
|
922
|
+
])).filter((name) => name !== null);
|
|
923
|
+
return down.length === 0 ? { ready: true } : { ready: false, failing: down };
|
|
924
|
+
};
|
|
925
|
+
const http = createHttpServer2({
|
|
926
|
+
config,
|
|
927
|
+
logger: platform.logger,
|
|
928
|
+
documentStore: platform.documentStore,
|
|
929
|
+
version
|
|
930
|
+
});
|
|
931
|
+
http.registerRoute("GET", "/ready", createReadyRoute(probe));
|
|
932
|
+
await app.attachHttp(http.adapter, { adminRoot: resolveAdminRoot() });
|
|
933
|
+
if (!(http.adapter instanceof FastifyHttpAdapter)) {
|
|
934
|
+
throw new Error("nymbal start needs the fastify http adapter");
|
|
935
|
+
}
|
|
936
|
+
const internalPort = await loopbackPort();
|
|
937
|
+
const forward = forwardToStorefront(http.adapter, { port: internalPort, publicUrl });
|
|
938
|
+
const storefront = spawn2(process.execPath, launch(internalPort), {
|
|
939
|
+
cwd: projectRoot,
|
|
940
|
+
stdio: "inherit",
|
|
941
|
+
env: {
|
|
942
|
+
...storefrontEnv2(process.env),
|
|
943
|
+
HOST: "127.0.0.1",
|
|
944
|
+
PORT: String(internalPort),
|
|
945
|
+
NYMBAL_API_URL: `http://127.0.0.1:${port}`,
|
|
946
|
+
NYMBAL_PUBLIC_URL: publicUrl
|
|
947
|
+
}
|
|
948
|
+
});
|
|
949
|
+
child2 = storefront;
|
|
950
|
+
const childGone = new Promise((resolveGone) => {
|
|
951
|
+
storefront.once("exit", () => resolveGone());
|
|
952
|
+
storefront.once("error", () => resolveGone());
|
|
953
|
+
});
|
|
954
|
+
process.on("exit", () => {
|
|
955
|
+
if (childAlive()) storefront.kill("SIGKILL");
|
|
956
|
+
});
|
|
957
|
+
if (!await listening(internalPort, childGone, STOREFRONT_START_MS)) {
|
|
958
|
+
fail([`The storefront did not start listening within ${STOREFRONT_START_MS / 1e3} s`]);
|
|
959
|
+
}
|
|
960
|
+
const bound = await http.start();
|
|
961
|
+
console.log(`nymbal start: ${publicUrl} on port ${bound.port}`);
|
|
962
|
+
const boundMs = shutdownBound(process.env);
|
|
963
|
+
const reserveMs = Math.min(3e3, Math.floor(boundMs * 0.3));
|
|
964
|
+
const steps = [
|
|
965
|
+
{
|
|
966
|
+
name: "ready.refuse",
|
|
967
|
+
run: async () => {
|
|
968
|
+
stopping = true;
|
|
969
|
+
}
|
|
970
|
+
},
|
|
971
|
+
{
|
|
972
|
+
name: "storefront.drain",
|
|
973
|
+
run: async () => {
|
|
974
|
+
forward.refuse();
|
|
975
|
+
if (!await forward.drained(boundMs - reserveMs)) {
|
|
976
|
+
platform.logger.warn({ inFlight: forward.inFlight() }, "Page requests still open");
|
|
977
|
+
}
|
|
978
|
+
}
|
|
979
|
+
},
|
|
980
|
+
{
|
|
981
|
+
name: "storefront.stop",
|
|
982
|
+
run: async () => {
|
|
983
|
+
if (!childAlive()) return;
|
|
984
|
+
storefront.kill("SIGTERM");
|
|
985
|
+
let timer;
|
|
986
|
+
const graceful = await Promise.race([
|
|
987
|
+
childGone.then(() => true),
|
|
988
|
+
new Promise((r) => timer = setTimeout(() => r(false), reserveMs / 2))
|
|
989
|
+
]);
|
|
990
|
+
clearTimeout(timer);
|
|
991
|
+
if (!graceful) {
|
|
992
|
+
storefront.kill("SIGKILL");
|
|
993
|
+
await childGone;
|
|
994
|
+
}
|
|
995
|
+
}
|
|
996
|
+
},
|
|
997
|
+
{ name: "http.stop", run: () => http.stop() },
|
|
998
|
+
{ name: "app.stop", run: () => app.stop() }
|
|
999
|
+
];
|
|
1000
|
+
let failed = false;
|
|
1001
|
+
const shutdown = (reason) => {
|
|
1002
|
+
platform.logger.info({ reason }, "Shutting down");
|
|
1003
|
+
return runShutdown(steps, {
|
|
1004
|
+
boundMs,
|
|
1005
|
+
logger: platform.logger,
|
|
1006
|
+
exit: (code) => process.exit(failed ? 1 : code)
|
|
1007
|
+
});
|
|
1008
|
+
};
|
|
1009
|
+
process.off("SIGTERM", stopBoot);
|
|
1010
|
+
process.off("SIGINT", stopBoot);
|
|
1011
|
+
process.on("SIGTERM", () => void shutdown("SIGTERM"));
|
|
1012
|
+
process.on("SIGINT", () => void shutdown("SIGINT"));
|
|
1013
|
+
void childGone.then(() => {
|
|
1014
|
+
if (stopping) return;
|
|
1015
|
+
failed = true;
|
|
1016
|
+
platform.logger.error(
|
|
1017
|
+
{ code: storefront.exitCode, signal: storefront.signalCode },
|
|
1018
|
+
"The storefront exited"
|
|
1019
|
+
);
|
|
1020
|
+
void shutdown("storefront-exit");
|
|
1021
|
+
});
|
|
1022
|
+
}
|
|
1023
|
+
});
|
|
1024
|
+
|
|
1025
|
+
// src/commands/deploy.ts
|
|
1026
|
+
import { spawnSync } from "child_process";
|
|
1027
|
+
import { accessSync, constants, existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
|
|
1028
|
+
import { delimiter, join as join5 } from "path";
|
|
1029
|
+
import { defineCommand as defineCommand5 } from "citty";
|
|
1030
|
+
import pc3 from "picocolors";
|
|
1031
|
+
import { DEFAULT_JWT_SECRET } from "@nymbalhq/config";
|
|
1032
|
+
var NYMBAL = "node node_modules/nymbal/bin/nymbal.mjs";
|
|
1033
|
+
var KILL_TIMEOUT_S = 15;
|
|
1034
|
+
var FROM_ENV = "<from .env>";
|
|
1035
|
+
function usesPostgres(config) {
|
|
1036
|
+
return config.infrastructure.commandStore === "postgres";
|
|
1037
|
+
}
|
|
1038
|
+
function usesRedis(config) {
|
|
1039
|
+
return config.infrastructure.documentStore.provider === "redis" || config.infrastructure.eventBus.provider === "redis-streams";
|
|
1040
|
+
}
|
|
1041
|
+
function prerequisites(config) {
|
|
1042
|
+
return config.commerce.payments.provider === "native" ? ["<first: configure a real payments provider (nymbal add stripe); production refuses the native stub>"] : [];
|
|
1043
|
+
}
|
|
1044
|
+
function jwtFromEnv(config) {
|
|
1045
|
+
return config.security.auth.jwtSecret === DEFAULT_JWT_SECRET;
|
|
1046
|
+
}
|
|
1047
|
+
var PROXY_HOPS = 1;
|
|
1048
|
+
function flyRecipe(project) {
|
|
1049
|
+
const { name, config } = project;
|
|
1050
|
+
const toml = [
|
|
1051
|
+
`app = "${name}"`,
|
|
1052
|
+
`kill_signal = "SIGTERM"`,
|
|
1053
|
+
`kill_timeout = ${KILL_TIMEOUT_S}`,
|
|
1054
|
+
"",
|
|
1055
|
+
"[build]",
|
|
1056
|
+
' dockerfile = "Dockerfile"',
|
|
1057
|
+
"",
|
|
1058
|
+
"[deploy]",
|
|
1059
|
+
` release_command = "${NYMBAL} migrate"`,
|
|
1060
|
+
"",
|
|
1061
|
+
"[env]",
|
|
1062
|
+
` NYMBAL_PUBLIC_URL = "https://${name}.fly.dev"`,
|
|
1063
|
+
` NYMBAL_TRUST_PROXY_HOPS = "${PROXY_HOPS}"`,
|
|
1064
|
+
"",
|
|
1065
|
+
"[http_service]",
|
|
1066
|
+
" internal_port = 3001",
|
|
1067
|
+
" force_https = true",
|
|
1068
|
+
"",
|
|
1069
|
+
" [[http_service.checks]]",
|
|
1070
|
+
' method = "GET"',
|
|
1071
|
+
' path = "/ready"',
|
|
1072
|
+
' interval = "15s"',
|
|
1073
|
+
' timeout = "6s"',
|
|
1074
|
+
' grace_period = "20s"',
|
|
1075
|
+
""
|
|
1076
|
+
].join("\n");
|
|
1077
|
+
const steps = [
|
|
1078
|
+
...prerequisites(config),
|
|
1079
|
+
`flyctl apps create ${name}`,
|
|
1080
|
+
...usesPostgres(config) ? [
|
|
1081
|
+
`flyctl postgres create --name ${name}-db`,
|
|
1082
|
+
`flyctl postgres attach ${name}-db --app ${name}`
|
|
1083
|
+
] : [],
|
|
1084
|
+
...usesRedis(config) ? [
|
|
1085
|
+
`flyctl redis create --name ${name}-redis`,
|
|
1086
|
+
`flyctl secrets set REDIS_URL=<from flyctl redis status ${name}-redis> --app ${name} --stage`
|
|
1087
|
+
] : [],
|
|
1088
|
+
`flyctl secrets set NYMBAL_SECRETS_KEY=${FROM_ENV} --app ${name} --stage`,
|
|
1089
|
+
...jwtFromEnv(config) ? [`flyctl secrets set NYMBAL_JWT_SECRET=${FROM_ENV} --app ${name} --stage`] : [],
|
|
1090
|
+
`flyctl deploy --app ${name}`
|
|
1091
|
+
];
|
|
1092
|
+
return { file: join5(project.root, "fly.toml"), toml, steps };
|
|
1093
|
+
}
|
|
1094
|
+
function railwayRecipe(project) {
|
|
1095
|
+
const { name, config } = project;
|
|
1096
|
+
const json2 = `${JSON.stringify(
|
|
1097
|
+
{
|
|
1098
|
+
$schema: "https://railway.com/railway.schema.json",
|
|
1099
|
+
build: { builder: "DOCKERFILE", dockerfilePath: "Dockerfile" },
|
|
1100
|
+
deploy: {
|
|
1101
|
+
preDeployCommand: [`${NYMBAL} migrate`],
|
|
1102
|
+
startCommand: `${NYMBAL} start`,
|
|
1103
|
+
healthcheckPath: "/ready",
|
|
1104
|
+
drainingSeconds: KILL_TIMEOUT_S,
|
|
1105
|
+
restartPolicyType: "ON_FAILURE"
|
|
1106
|
+
}
|
|
1107
|
+
},
|
|
1108
|
+
null,
|
|
1109
|
+
2
|
|
1110
|
+
)}
|
|
1111
|
+
`;
|
|
1112
|
+
const service = `--service ${name}`;
|
|
1113
|
+
const steps = [
|
|
1114
|
+
...prerequisites(config),
|
|
1115
|
+
`railway init --name ${name}`,
|
|
1116
|
+
...usesPostgres(config) ? ["railway add --database postgres"] : [],
|
|
1117
|
+
...usesRedis(config) ? ["railway add --database redis"] : [],
|
|
1118
|
+
`railway add ${service}`,
|
|
1119
|
+
...usesPostgres(config) ? [`railway variables ${service} --set 'DATABASE_URL=\${{Postgres.DATABASE_URL}}'`] : [],
|
|
1120
|
+
...usesRedis(config) ? [`railway variables ${service} --set 'REDIS_URL=\${{Redis.REDIS_URL}}'`] : [],
|
|
1121
|
+
`railway variables ${service} --set 'NYMBAL_PUBLIC_URL=https://\${{RAILWAY_PUBLIC_DOMAIN}}'`,
|
|
1122
|
+
`railway variables ${service} --set NYMBAL_SECRETS_KEY=${FROM_ENV}`,
|
|
1123
|
+
...jwtFromEnv(config) ? [`railway variables ${service} --set NYMBAL_JWT_SECRET=${FROM_ENV}`] : [],
|
|
1124
|
+
`railway variables ${service} --set NYMBAL_TRUST_PROXY_HOPS=${PROXY_HOPS}`,
|
|
1125
|
+
`railway domain ${service}`,
|
|
1126
|
+
`railway up ${service}`
|
|
1127
|
+
];
|
|
1128
|
+
return { file: join5(project.root, "railway.json"), json: json2, steps };
|
|
1129
|
+
}
|
|
1130
|
+
function onPath(command) {
|
|
1131
|
+
for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
|
|
1132
|
+
if (dir === "") continue;
|
|
1133
|
+
try {
|
|
1134
|
+
accessSync(join5(dir, command), constants.X_OK);
|
|
1135
|
+
return true;
|
|
1136
|
+
} catch {
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
return false;
|
|
1140
|
+
}
|
|
1141
|
+
function appName(root) {
|
|
1142
|
+
const pkg = JSON.parse(readFileSync3(join5(root, "package.json"), "utf8"));
|
|
1143
|
+
const name = (pkg.name ?? "").replace(/^@/, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
|
|
1144
|
+
if (name === "") throw new Error('package.json needs a "name" to name the app');
|
|
1145
|
+
return name;
|
|
1146
|
+
}
|
|
1147
|
+
function runSteps(steps, tool) {
|
|
1148
|
+
for (const step of steps) {
|
|
1149
|
+
console.log(pc3.dim(`$ ${step}`));
|
|
1150
|
+
const unresolved = /<(?!from \.env>)[^>]+>/.exec(step);
|
|
1151
|
+
if (unresolved) {
|
|
1152
|
+
process.stderr.write(
|
|
1153
|
+
`${pc3.yellow(`Finish from here by hand: this step needs ${unresolved[0]}.`)}
|
|
1154
|
+
`
|
|
1155
|
+
);
|
|
1156
|
+
process.exit(1);
|
|
1157
|
+
}
|
|
1158
|
+
const argv = (step.match(/'[^']*'|\S+/g) ?? []).map(
|
|
1159
|
+
(part) => part.startsWith("'") ? part.slice(1, -1) : part
|
|
1160
|
+
);
|
|
1161
|
+
const filled = argv.map((part) => {
|
|
1162
|
+
const at = part.indexOf(FROM_ENV);
|
|
1163
|
+
if (at < 0) return part;
|
|
1164
|
+
const key = part.slice(0, at - 1);
|
|
1165
|
+
const value = process.env[key];
|
|
1166
|
+
if (value === void 0 || value === "") {
|
|
1167
|
+
const make = key === "NYMBAL_JWT_SECRET" ? ": add one made by `openssl rand -base64 32`" : "";
|
|
1168
|
+
process.stderr.write(`${pc3.red(`${key} is not set in .env${make}`)}
|
|
1169
|
+
`);
|
|
1170
|
+
process.exit(1);
|
|
1171
|
+
}
|
|
1172
|
+
return `${key}=${value}`;
|
|
1173
|
+
});
|
|
1174
|
+
const done = spawnSync(filled[0], filled.slice(1), { stdio: "inherit" });
|
|
1175
|
+
if (done.status !== 0) {
|
|
1176
|
+
process.stderr.write(`${pc3.red(`${tool} step failed: ${step}`)}
|
|
1177
|
+
`);
|
|
1178
|
+
process.exit(1);
|
|
1179
|
+
}
|
|
1180
|
+
}
|
|
1181
|
+
}
|
|
1182
|
+
function platformCommand(platform) {
|
|
1183
|
+
const tool = platform === "fly" ? "flyctl" : "railway";
|
|
1184
|
+
return defineCommand5({
|
|
1185
|
+
meta: {
|
|
1186
|
+
name: platform,
|
|
1187
|
+
description: `Write ${platform === "fly" ? "fly.toml" : "railway.json"} and deploy with ${tool}`
|
|
1188
|
+
},
|
|
1189
|
+
args: {
|
|
1190
|
+
dryRun: {
|
|
1191
|
+
type: "boolean",
|
|
1192
|
+
alias: "dry-run",
|
|
1193
|
+
description: "Write the recipe and print the steps; run nothing",
|
|
1194
|
+
default: false
|
|
1195
|
+
}
|
|
1196
|
+
},
|
|
1197
|
+
async run({ args }) {
|
|
1198
|
+
const { config, projectRoot } = await loadProject();
|
|
1199
|
+
if (!args.dryRun && !onPath(tool)) {
|
|
1200
|
+
process.stderr.write(
|
|
1201
|
+
`${pc3.red(`${tool} is not on PATH.`)} Install it and log in, or run with --dry-run to see the steps.
|
|
1202
|
+
`
|
|
1203
|
+
);
|
|
1204
|
+
process.exit(1);
|
|
1205
|
+
}
|
|
1206
|
+
const project = { name: appName(projectRoot), root: projectRoot, config };
|
|
1207
|
+
const recipe = platform === "fly" ? flyRecipe(project) : railwayRecipe(project);
|
|
1208
|
+
const content = "toml" in recipe ? recipe.toml : recipe.json;
|
|
1209
|
+
if (!existsSync7(join5(projectRoot, "Dockerfile"))) {
|
|
1210
|
+
console.log(pc3.yellow("No Dockerfile yet: `nymbal build --image` writes one."));
|
|
1211
|
+
}
|
|
1212
|
+
writeFileSync2(recipe.file, content);
|
|
1213
|
+
console.log(`\u2713 wrote ${recipe.file}`);
|
|
1214
|
+
if (args.dryRun) {
|
|
1215
|
+
console.log(`
|
|
1216
|
+
The steps, with ${tool}:
|
|
1217
|
+
${recipe.steps.map((s) => ` ${s}`).join("\n")}`);
|
|
1218
|
+
return;
|
|
1219
|
+
}
|
|
1220
|
+
const whoami = spawnSync(tool, platform === "fly" ? ["auth", "whoami"] : ["whoami"], {
|
|
1221
|
+
stdio: "ignore"
|
|
1222
|
+
});
|
|
1223
|
+
if (whoami.status !== 0) {
|
|
1224
|
+
process.stderr.write(
|
|
1225
|
+
`${pc3.red(`${tool} is not logged in.`)} Run \`${tool === "flyctl" ? "flyctl auth login" : "railway login"}\` first.
|
|
1226
|
+
`
|
|
1227
|
+
);
|
|
1228
|
+
process.exit(1);
|
|
1229
|
+
}
|
|
1230
|
+
runSteps(recipe.steps, tool);
|
|
1231
|
+
}
|
|
1232
|
+
});
|
|
1233
|
+
}
|
|
1234
|
+
var deployCommand = defineCommand5({
|
|
1235
|
+
meta: { name: "deploy", description: "Deploy the store to Fly or Railway" },
|
|
1236
|
+
subCommands: {
|
|
1237
|
+
fly: platformCommand("fly"),
|
|
1238
|
+
railway: platformCommand("railway")
|
|
1239
|
+
}
|
|
1240
|
+
});
|
|
1241
|
+
|
|
1242
|
+
// src/commands/seed.ts
|
|
1243
|
+
import { defineCommand as defineCommand6 } from "citty";
|
|
1244
|
+
import { createPlatform, resolveChoice, resolvePrimitives, runSeed as runSeed2 } from "@nymbalhq/platform";
|
|
1245
|
+
var seedCommand = defineCommand6({
|
|
551
1246
|
meta: { name: "seed", description: "Re-seed demo content (products, categories)" },
|
|
552
1247
|
args: {
|
|
553
1248
|
localImages: {
|
|
@@ -584,6 +1279,10 @@ var seedCommand = defineCommand4({
|
|
|
584
1279
|
console.log(
|
|
585
1280
|
result.alreadySeeded ? "\u2713 demo content already present, nothing to seed" : `\u2713 seeded ${result.products} products across ${result.categories} categories`
|
|
586
1281
|
);
|
|
1282
|
+
const search = config.commerce.search;
|
|
1283
|
+
if (!result.alreadySeeded && resolveChoice("search", search).kind === "package") {
|
|
1284
|
+
console.log(`search: run \`nymbal replay --to search\` to fill ${search.provider}`);
|
|
1285
|
+
}
|
|
587
1286
|
} finally {
|
|
588
1287
|
await platform.close();
|
|
589
1288
|
}
|
|
@@ -591,13 +1290,13 @@ var seedCommand = defineCommand4({
|
|
|
591
1290
|
});
|
|
592
1291
|
|
|
593
1292
|
// src/commands/import.ts
|
|
594
|
-
import { defineCommand as
|
|
1293
|
+
import { defineCommand as defineCommand7 } from "citty";
|
|
595
1294
|
import { intro, outro, text, select, spinner, isCancel, cancel } from "@clack/prompts";
|
|
596
1295
|
import p from "picocolors";
|
|
597
|
-
import { createApp as
|
|
1296
|
+
import { createApp as createApp3, newCorrelationId, runAsActor, runWithCorrelation } from "@nymbalhq/platform";
|
|
598
1297
|
import { runWooCommerceImport, writeReport } from "@nymbalhq/importers";
|
|
599
|
-
import { join as
|
|
600
|
-
var importCommand =
|
|
1298
|
+
import { join as join6 } from "path";
|
|
1299
|
+
var importCommand = defineCommand7({
|
|
601
1300
|
meta: {
|
|
602
1301
|
name: "import",
|
|
603
1302
|
description: "Migrate content from WooCommerce (or other sources) into Nymbal"
|
|
@@ -646,7 +1345,7 @@ var importCommand = defineCommand5({
|
|
|
646
1345
|
async run({ args }) {
|
|
647
1346
|
const { config } = await loadProject();
|
|
648
1347
|
const projectRoot = process.cwd();
|
|
649
|
-
const statePath =
|
|
1348
|
+
const statePath = join6(projectRoot, ".nymbal-migration.json");
|
|
650
1349
|
const isTTY = process.stdin.isTTY ?? false;
|
|
651
1350
|
intro(p.bold("Nymbal Import"));
|
|
652
1351
|
let source = args.source;
|
|
@@ -719,7 +1418,7 @@ var importCommand = defineCommand5({
|
|
|
719
1418
|
const gdprEnabled = args.gdpr !== false;
|
|
720
1419
|
const loadSpin = spinner();
|
|
721
1420
|
loadSpin.start("Starting platform\u2026");
|
|
722
|
-
const app = await
|
|
1421
|
+
const app = await createApp3(config, { version: getCliVersion() });
|
|
723
1422
|
loadSpin.stop("Platform ready");
|
|
724
1423
|
try {
|
|
725
1424
|
const report = await runWithCorrelation(
|
|
@@ -777,22 +1476,23 @@ var importCommand = defineCommand5({
|
|
|
777
1476
|
});
|
|
778
1477
|
|
|
779
1478
|
// src/commands/config-validate.ts
|
|
780
|
-
import { defineCommand as
|
|
781
|
-
import
|
|
1479
|
+
import { defineCommand as defineCommand8 } from "citty";
|
|
1480
|
+
import pc4 from "picocolors";
|
|
1481
|
+
import { slotFolder as slotFolder2 } from "@nymbalhq/config";
|
|
782
1482
|
import { NymbalError } from "@nymbalhq/types";
|
|
783
|
-
var configValidateCommand =
|
|
1483
|
+
var configValidateCommand = defineCommand8({
|
|
784
1484
|
meta: { name: "config:validate", description: "Validate nymbal.config.ts" },
|
|
785
1485
|
async run() {
|
|
786
1486
|
try {
|
|
787
1487
|
const { config, path } = await loadProject();
|
|
788
|
-
console.log(
|
|
1488
|
+
console.log(pc4.green(`\u2713 config valid`) + ` (${path})`);
|
|
789
1489
|
console.log(
|
|
790
|
-
` template: ${config.template},
|
|
1490
|
+
` template: ${config.template}, command store: ${config.infrastructure.commandStore}, ${slotFolder2("documentStore")}: ${config.infrastructure.documentStore.provider}, ${slotFolder2("eventBus")}: ${config.infrastructure.eventBus.provider}`
|
|
791
1491
|
);
|
|
792
1492
|
process.exit(0);
|
|
793
1493
|
} catch (err2) {
|
|
794
1494
|
if (err2 instanceof NymbalError) {
|
|
795
|
-
console.error(
|
|
1495
|
+
console.error(pc4.red("\u2717 config invalid"));
|
|
796
1496
|
console.error(err2.message);
|
|
797
1497
|
} else {
|
|
798
1498
|
console.error(err2);
|
|
@@ -803,28 +1503,49 @@ var configValidateCommand = defineCommand6({
|
|
|
803
1503
|
});
|
|
804
1504
|
|
|
805
1505
|
// src/commands/add.ts
|
|
806
|
-
import { spawnSync } from "child_process";
|
|
807
|
-
import { existsSync as
|
|
808
|
-
import { dirname as dirname6, join as
|
|
1506
|
+
import { spawnSync as spawnSync2 } from "child_process";
|
|
1507
|
+
import { existsSync as existsSync9, mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync3 } from "fs";
|
|
1508
|
+
import { dirname as dirname6, join as join8 } from "path";
|
|
1509
|
+
import { pathToFileURL as pathToFileURL2 } from "url";
|
|
809
1510
|
import { parseEnv } from "util";
|
|
810
|
-
import { defineCommand as
|
|
811
|
-
import
|
|
812
|
-
import
|
|
813
|
-
import {
|
|
1511
|
+
import { defineCommand as defineCommand9 } from "citty";
|
|
1512
|
+
import { resolve as resolveFrom } from "import-meta-resolve";
|
|
1513
|
+
import pc5 from "picocolors";
|
|
1514
|
+
import {
|
|
1515
|
+
ADAPTER_CATALOGUE as ADAPTER_CATALOGUE2,
|
|
1516
|
+
BUILT_IN,
|
|
1517
|
+
PROVIDER_NAME,
|
|
1518
|
+
conventionPackage as conventionPackage2,
|
|
1519
|
+
findConfigFile as findConfigFile2,
|
|
1520
|
+
loadConfig as loadConfig2,
|
|
1521
|
+
slotFolder as slotFolder5,
|
|
1522
|
+
suggestProvider
|
|
1523
|
+
} from "@nymbalhq/config";
|
|
1524
|
+
import { checkAdapterModule, installLine, missingPackage, resolveChoice as resolveChoice2 } from "@nymbalhq/platform";
|
|
814
1525
|
|
|
815
1526
|
// src/recipes/holders.ts
|
|
816
|
-
import { existsSync as
|
|
1527
|
+
import { existsSync as existsSync8 } from "fs";
|
|
817
1528
|
import { readFile } from "fs/promises";
|
|
818
|
-
import { createRequire as
|
|
819
|
-
import { dirname as dirname5, join as
|
|
1529
|
+
import { createRequire as createRequire3 } from "module";
|
|
1530
|
+
import { dirname as dirname5, join as join7, resolve as resolve6 } from "path";
|
|
820
1531
|
import { pathToFileURL } from "url";
|
|
1532
|
+
import { conventionPackage } from "@nymbalhq/config";
|
|
821
1533
|
var RECIPE_HOLDERS = {
|
|
822
|
-
|
|
1534
|
+
algolia: conventionPackage("search", "algolia"),
|
|
1535
|
+
cloudflare: conventionPackage("security", "cloudflare"),
|
|
823
1536
|
postgres: "@nymbalhq/platform",
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
1537
|
+
// Sets the document store and the bus; the document store's package ships it.
|
|
1538
|
+
redis: conventionPackage("documentStore", "redis"),
|
|
1539
|
+
s3: conventionPackage("media", "s3"),
|
|
1540
|
+
stripe: conventionPackage("payments", "stripe")
|
|
1541
|
+
};
|
|
1542
|
+
var MULTI_SLOT_PAIRS = {
|
|
1543
|
+
redis: ["documentStore/redis", "eventBus/redis-streams"]
|
|
827
1544
|
};
|
|
1545
|
+
function multiSlotRecipe(slot, provider) {
|
|
1546
|
+
const pair = `${slot}/${provider}`;
|
|
1547
|
+
return Object.keys(MULTI_SLOT_PAIRS).find((name) => MULTI_SLOT_PAIRS[name].includes(pair));
|
|
1548
|
+
}
|
|
828
1549
|
function knownRecipes() {
|
|
829
1550
|
return Object.keys(RECIPE_HOLDERS).sort();
|
|
830
1551
|
}
|
|
@@ -835,28 +1556,31 @@ function unknownRecipe(name) {
|
|
|
835
1556
|
return new Error(`unknown recipe '${name}': the recipes are ${knownRecipes().join(", ")}`);
|
|
836
1557
|
}
|
|
837
1558
|
function packageDir(pkg, projectRoot) {
|
|
838
|
-
let dir =
|
|
1559
|
+
let dir = resolve6(projectRoot);
|
|
839
1560
|
while (true) {
|
|
840
|
-
const candidate =
|
|
841
|
-
if (
|
|
1561
|
+
const candidate = join7(dir, "node_modules", pkg);
|
|
1562
|
+
if (existsSync8(join7(candidate, "package.json"))) return candidate;
|
|
842
1563
|
const parent = dirname5(dir);
|
|
843
1564
|
if (parent === dir) return null;
|
|
844
1565
|
dir = parent;
|
|
845
1566
|
}
|
|
846
1567
|
}
|
|
847
|
-
function
|
|
848
|
-
const
|
|
849
|
-
if (holder === void 0 || !isKnownRecipe(name)) throw unknownRecipe(name);
|
|
850
|
-
const dir = packageDir(holder, projectRoot);
|
|
1568
|
+
function packageRecipeFile(pkg, name, projectRoot) {
|
|
1569
|
+
const dir = packageDir(pkg, projectRoot);
|
|
851
1570
|
if (dir === null) return null;
|
|
852
1571
|
try {
|
|
853
|
-
return
|
|
1572
|
+
return createRequire3(join7(dir, "package.json")).resolve(`${pkg}/recipes/${name}.json`);
|
|
854
1573
|
} catch (error) {
|
|
855
1574
|
const code = error.code;
|
|
856
1575
|
if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return null;
|
|
857
1576
|
throw error;
|
|
858
1577
|
}
|
|
859
1578
|
}
|
|
1579
|
+
function recipeFile(name, projectRoot) {
|
|
1580
|
+
const holder = RECIPE_HOLDERS[name];
|
|
1581
|
+
if (holder === void 0 || !isKnownRecipe(name)) throw unknownRecipe(name);
|
|
1582
|
+
return packageRecipeFile(holder, name, projectRoot);
|
|
1583
|
+
}
|
|
860
1584
|
function isInstalled(pkg, projectRoot) {
|
|
861
1585
|
return packageDir(pkg, projectRoot) !== null;
|
|
862
1586
|
}
|
|
@@ -867,6 +1591,9 @@ async function readRecipe(name, projectRoot) {
|
|
|
867
1591
|
`${RECIPE_HOLDERS[name]} is not installed in ${projectRoot}, so its ${name} recipe cannot be read`
|
|
868
1592
|
);
|
|
869
1593
|
}
|
|
1594
|
+
return readRecipeFile(file, name);
|
|
1595
|
+
}
|
|
1596
|
+
async function readRecipeFile(file, name) {
|
|
870
1597
|
const recipe = JSON.parse(await readFile(file, "utf8"));
|
|
871
1598
|
const malformed = recipe === null || typeof recipe !== "object" || recipe.name !== name || !Array.isArray(recipe.install) || !Array.isArray(recipe.set) || !Array.isArray(recipe.env) || !Array.isArray(recipe.next);
|
|
872
1599
|
if (malformed) throw new Error(`${file} is not a ${name} recipe`);
|
|
@@ -876,22 +1603,21 @@ function entryOf(dir, manifest) {
|
|
|
876
1603
|
const exportsField = manifest["exports"];
|
|
877
1604
|
const root = typeof exportsField === "object" ? exportsField["."] : exportsField;
|
|
878
1605
|
const entry = typeof root === "string" ? root : typeof root === "object" && root !== null ? root["import"] ?? root["default"] : manifest["module"] ?? manifest["main"];
|
|
879
|
-
return typeof entry === "string" ?
|
|
1606
|
+
return typeof entry === "string" ? join7(dir, entry) : null;
|
|
880
1607
|
}
|
|
881
1608
|
async function settingsEnv(packages, projectRoot) {
|
|
882
1609
|
const names = /* @__PURE__ */ new Set();
|
|
883
|
-
for (const pkg of packages
|
|
1610
|
+
for (const pkg of packages) {
|
|
884
1611
|
const dir = packageDir(pkg, projectRoot);
|
|
885
1612
|
if (dir === null) continue;
|
|
886
|
-
const manifest = JSON.parse(await readFile(
|
|
1613
|
+
const manifest = JSON.parse(await readFile(join7(dir, "package.json"), "utf8"));
|
|
887
1614
|
const entry = entryOf(dir, manifest);
|
|
888
|
-
if (entry === null || !
|
|
1615
|
+
if (entry === null || !existsSync8(entry)) continue;
|
|
889
1616
|
let mod;
|
|
890
1617
|
try {
|
|
891
1618
|
mod = await import(pathToFileURL(entry).href);
|
|
892
|
-
} catch
|
|
893
|
-
|
|
894
|
-
throw error;
|
|
1619
|
+
} catch {
|
|
1620
|
+
continue;
|
|
895
1621
|
}
|
|
896
1622
|
if (!Array.isArray(mod.settings)) continue;
|
|
897
1623
|
for (const setting of mod.settings) {
|
|
@@ -909,6 +1635,7 @@ var SCAFFOLD_DEFAULTS = [
|
|
|
909
1635
|
"in-process",
|
|
910
1636
|
"local-fs",
|
|
911
1637
|
"native",
|
|
1638
|
+
"none",
|
|
912
1639
|
"middleware"
|
|
913
1640
|
];
|
|
914
1641
|
var CONFIG_MODULE = "@nymbalhq/config";
|
|
@@ -1275,19 +2002,115 @@ function appendRecipeEnv(example, recipe) {
|
|
|
1275
2002
|
return `${head}${gap}${block.join(eol)}${eol}`;
|
|
1276
2003
|
}
|
|
1277
2004
|
|
|
2005
|
+
// src/recipes/slot-recipe.ts
|
|
2006
|
+
import { slotFolder as slotFolder3 } from "@nymbalhq/config";
|
|
2007
|
+
var INFRASTRUCTURE = /* @__PURE__ */ new Set(["documentStore", "eventBus", "media"]);
|
|
2008
|
+
function slotPath(slot) {
|
|
2009
|
+
if (slot === "security") return "security";
|
|
2010
|
+
return INFRASTRUCTURE.has(slot) ? `infrastructure.${slot}` : `commerce.${slot}`;
|
|
2011
|
+
}
|
|
2012
|
+
function slotAt(path) {
|
|
2013
|
+
const [top, key] = path.split(".");
|
|
2014
|
+
return (top === "commerce" || top === "infrastructure") && key !== void 0 ? key : top;
|
|
2015
|
+
}
|
|
2016
|
+
function slotsSetBy(recipe) {
|
|
2017
|
+
return [...new Set(recipe.set.map(({ path }) => slotFolder3(slotAt(path))))];
|
|
2018
|
+
}
|
|
2019
|
+
function setsOnly(recipe, slot) {
|
|
2020
|
+
const base = slotPath(slot);
|
|
2021
|
+
return recipe.set.every(({ path }) => path === base || path.startsWith(`${base}.`));
|
|
2022
|
+
}
|
|
2023
|
+
function slotRecipe(opts) {
|
|
2024
|
+
const { slot, provider, settings } = opts;
|
|
2025
|
+
const set = slot === "security" ? [
|
|
2026
|
+
{ path: "security.adapter", value: provider },
|
|
2027
|
+
...opts.package === void 0 ? [] : [{ path: "security.package", value: opts.package }]
|
|
2028
|
+
] : [
|
|
2029
|
+
{
|
|
2030
|
+
path: slotPath(slot),
|
|
2031
|
+
value: { provider, ...opts.package !== void 0 && { package: opts.package } }
|
|
2032
|
+
}
|
|
2033
|
+
];
|
|
2034
|
+
const from = opts.package === void 0 ? "" : ` from ${opts.package}`;
|
|
2035
|
+
return {
|
|
2036
|
+
name: opts.name,
|
|
2037
|
+
summary: `${slotFolder3(slot)} is ${provider}${from}`,
|
|
2038
|
+
install: opts.install,
|
|
2039
|
+
set,
|
|
2040
|
+
env: settings.flatMap(
|
|
2041
|
+
(s) => s.env === void 0 ? [] : [{ name: s.env, example: "", required: s.optional !== true, comment: s.label }]
|
|
2042
|
+
),
|
|
2043
|
+
next: [
|
|
2044
|
+
...settings.filter((s) => s.env === void 0).map((s) => `set ${s.path} in the admin's Settings (${s.label})`),
|
|
2045
|
+
...INFRASTRUCTURE.has(slot) && settings.length === 0 ? [`run nymbal doctor to check ${slotFolder3(slot)} on ${provider}`] : []
|
|
2046
|
+
]
|
|
2047
|
+
};
|
|
2048
|
+
}
|
|
2049
|
+
|
|
2050
|
+
// src/slot-names.ts
|
|
2051
|
+
import { ADAPTER_CATALOGUE, slotFolder as slotFolder4 } from "@nymbalhq/config";
|
|
2052
|
+
var SLOTS = Object.keys(ADAPTER_CATALOGUE);
|
|
2053
|
+
function slotNamed(word) {
|
|
2054
|
+
return SLOTS.find((slot) => slot === word || slotFolder4(slot) === word);
|
|
2055
|
+
}
|
|
2056
|
+
|
|
1278
2057
|
// src/commands/add.ts
|
|
2058
|
+
var SLOTS2 = Object.keys(ADAPTER_CATALOGUE2);
|
|
2059
|
+
var PACKAGE_NAME = /^@[a-z0-9-~][a-z0-9-._~]*\/[a-z0-9-~][a-z0-9-._~]*$/;
|
|
2060
|
+
var usageHint = () => `nymbal add takes <recipe> (${knownRecipes().join(", ")}), <slot> <provider> or <package> (a scoped npm name, @scope/name)`;
|
|
2061
|
+
function parseAddTarget(args) {
|
|
2062
|
+
if (args.length === 1) {
|
|
2063
|
+
const name = args[0];
|
|
2064
|
+
if (isKnownRecipe(name)) return { kind: "recipe", name };
|
|
2065
|
+
if (PACKAGE_NAME.test(name)) return { kind: "package", name };
|
|
2066
|
+
const slot = slotNamed(name);
|
|
2067
|
+
if (slot !== void 0) {
|
|
2068
|
+
return {
|
|
2069
|
+
error: `name the ${slotFolder5(slot)} provider: nymbal add ${slotFolder5(slot)} <provider>, one of ${Object.keys(ADAPTER_CATALOGUE2[slot]).join(", ")}. ${usageHint()}`
|
|
2070
|
+
};
|
|
2071
|
+
}
|
|
2072
|
+
return { error: `unknown name '${name}'. ${usageHint()}` };
|
|
2073
|
+
}
|
|
2074
|
+
if (args.length === 2) {
|
|
2075
|
+
const [word, provider] = args;
|
|
2076
|
+
const slot = slotNamed(word);
|
|
2077
|
+
if (slot === void 0)
|
|
2078
|
+
return { error: `unknown slot '${word}'; the slots are ${SLOTS2.map(slotFolder5).join(", ")}` };
|
|
2079
|
+
return { kind: "slot", slot, provider };
|
|
2080
|
+
}
|
|
2081
|
+
return {
|
|
2082
|
+
error: `${args.length === 0 ? "name what to add" : `nymbal add takes one or two names, not ${args.length}`}. ${usageHint()}`
|
|
2083
|
+
};
|
|
2084
|
+
}
|
|
2085
|
+
function addUsage() {
|
|
2086
|
+
const forms = [
|
|
2087
|
+
["nymbal add <recipe>", `a service, as in nymbal add redis: ${knownRecipes().join(", ")}`],
|
|
2088
|
+
["nymbal add <slot> <provider>", "one slot on a provider, as in nymbal add media s3"],
|
|
2089
|
+
["nymbal add <package>", "a third-party adapter by its npm name, as in nymbal add @acme/x"]
|
|
2090
|
+
];
|
|
2091
|
+
const lines = ["Forms:"];
|
|
2092
|
+
for (const [form, what] of forms) lines.push(` ${form.padEnd(30)}${what}`);
|
|
2093
|
+
lines.push("", "Slots and the providers Nymbal ships:");
|
|
2094
|
+
for (const slot of SLOTS2) {
|
|
2095
|
+
const providers = Object.entries(ADAPTER_CATALOGUE2[slot]).map(
|
|
2096
|
+
([provider, entry]) => entry.builtIn === true ? `${provider} (built in)` : provider
|
|
2097
|
+
);
|
|
2098
|
+
lines.push(` ${slotFolder5(slot)}: ${providers.join(", ")}`);
|
|
2099
|
+
}
|
|
2100
|
+
return lines.join("\n");
|
|
2101
|
+
}
|
|
1279
2102
|
var out = (line = "") => void process.stdout.write(`${line}
|
|
1280
2103
|
`);
|
|
1281
2104
|
var err = (line) => void process.stderr.write(`${line}
|
|
1282
2105
|
`);
|
|
1283
|
-
function
|
|
1284
|
-
err(
|
|
2106
|
+
function fail2(message) {
|
|
2107
|
+
err(pc5.red(`\u2717 ${message}`));
|
|
1285
2108
|
return 1;
|
|
1286
2109
|
}
|
|
1287
2110
|
function runInstall(line, root) {
|
|
1288
|
-
out(
|
|
2111
|
+
out(pc5.dim(`$ ${line}`));
|
|
1289
2112
|
const [command, ...args] = line.split(" ");
|
|
1290
|
-
const result =
|
|
2113
|
+
const result = spawnSync2(command, args, {
|
|
1291
2114
|
cwd: root,
|
|
1292
2115
|
stdio: "inherit",
|
|
1293
2116
|
shell: process.platform === "win32"
|
|
@@ -1295,8 +2118,8 @@ function runInstall(line, root) {
|
|
|
1295
2118
|
return result.status === 0;
|
|
1296
2119
|
}
|
|
1297
2120
|
function dotEnv(root) {
|
|
1298
|
-
const file =
|
|
1299
|
-
return
|
|
2121
|
+
const file = join8(root, ".env");
|
|
2122
|
+
return existsSync9(file) ? parseEnv(readFileSync4(file, "utf8")) : {};
|
|
1300
2123
|
}
|
|
1301
2124
|
var isSet = (name, fromFile) => (process.env[name] ?? "") !== "" || (fromFile[name] ?? "") !== "";
|
|
1302
2125
|
async function problemsWith(candidate, recipe, root, fromFile) {
|
|
@@ -1315,9 +2138,9 @@ async function problemsWith(candidate, recipe, root, fromFile) {
|
|
|
1315
2138
|
saved.set(name, process.env[name]);
|
|
1316
2139
|
process.env[name] = value;
|
|
1317
2140
|
}
|
|
1318
|
-
const dir = mkdtempSync(
|
|
2141
|
+
const dir = mkdtempSync(join8(root, ".nymbal-add-"));
|
|
1319
2142
|
try {
|
|
1320
|
-
|
|
2143
|
+
writeFileSync3(join8(dir, "nymbal.config.ts"), candidate);
|
|
1321
2144
|
await loadConfig2(dir);
|
|
1322
2145
|
} catch (error) {
|
|
1323
2146
|
problems.push(error.message);
|
|
@@ -1345,54 +2168,207 @@ function lineDiff(before, after) {
|
|
|
1345
2168
|
i++;
|
|
1346
2169
|
j++;
|
|
1347
2170
|
} else if (j < b.length && (i === a.length || t[i][j + 1] >= t[i + 1][j])) {
|
|
1348
|
-
lines.push(
|
|
2171
|
+
lines.push(pc5.green(`+ ${b[j++]}`));
|
|
1349
2172
|
} else {
|
|
1350
|
-
lines.push(
|
|
2173
|
+
lines.push(pc5.red(`- ${a[i++]}`));
|
|
1351
2174
|
}
|
|
1352
2175
|
}
|
|
1353
2176
|
return lines;
|
|
1354
2177
|
}
|
|
1355
2178
|
var show = (value) => typeof value === "string" ? `'${value}'` : JSON.stringify(value);
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
2179
|
+
var messageOf = (error) => error instanceof Error ? error.message : String(error);
|
|
2180
|
+
function removeLine(pkg, root) {
|
|
2181
|
+
return installLine([pkg], process.env, root).replace(
|
|
2182
|
+
/^(\S+) \S+/,
|
|
2183
|
+
(_, pm) => `${pm} ${pm === "npm" ? "uninstall" : "remove"}`
|
|
2184
|
+
);
|
|
2185
|
+
}
|
|
2186
|
+
function ensureInstalled(pkg, packages, notInstalled, root, opts, installed) {
|
|
2187
|
+
if (isInstalled(pkg, root)) return null;
|
|
2188
|
+
const line = installLine(packages, process.env, root);
|
|
2189
|
+
if (!opts.install || opts.dryRun) return fail2(`${notInstalled}. Install it: ${line}`);
|
|
2190
|
+
if (!runInstall(line, root)) return fail2(`${line} failed`);
|
|
2191
|
+
installed.push(...packages);
|
|
2192
|
+
return null;
|
|
2193
|
+
}
|
|
2194
|
+
async function importFromProject(pkg, root) {
|
|
2195
|
+
const mod = await import(resolveFrom(pkg, pathToFileURL2(join8(root, "package.json")).href));
|
|
2196
|
+
return mod ?? {};
|
|
2197
|
+
}
|
|
2198
|
+
function loadFailure(pkg, error, root) {
|
|
2199
|
+
const missing = missingPackage(error);
|
|
2200
|
+
const install = missing === null || missing === pkg ? "" : `: ${installLine([missing], process.env, root)}`;
|
|
2201
|
+
return `${pkg} could not be loaded: ${messageOf(error)}${install}`;
|
|
2202
|
+
}
|
|
2203
|
+
async function packageRecipe(file, provider, slot) {
|
|
2204
|
+
const recipe = await readRecipeFile(file, provider);
|
|
2205
|
+
if (!setsOnly(recipe, slot)) {
|
|
2206
|
+
return fail2(
|
|
2207
|
+
`${recipe.name} sets ${slotsSetBy(recipe).join(" and ")} together: run nymbal add ${recipe.name}`
|
|
2208
|
+
);
|
|
1360
2209
|
}
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
|
|
2210
|
+
return recipe;
|
|
2211
|
+
}
|
|
2212
|
+
async function recipePlan(name, root, opts, installed) {
|
|
1364
2213
|
const holder = RECIPE_HOLDERS[name];
|
|
1365
|
-
const installed = [];
|
|
1366
2214
|
if (recipeFile(name, root) === null) {
|
|
1367
|
-
const
|
|
1368
|
-
|
|
1369
|
-
|
|
1370
|
-
|
|
1371
|
-
|
|
1372
|
-
|
|
1373
|
-
|
|
1374
|
-
|
|
2215
|
+
const failed = ensureInstalled(
|
|
2216
|
+
holder,
|
|
2217
|
+
[holder],
|
|
2218
|
+
`the ${name} recipe ships in ${holder}, which is not installed`,
|
|
2219
|
+
root,
|
|
2220
|
+
opts,
|
|
2221
|
+
installed
|
|
2222
|
+
);
|
|
2223
|
+
if (failed !== null) return failed;
|
|
1375
2224
|
}
|
|
1376
2225
|
const recipe = await readRecipe(name, root);
|
|
1377
|
-
|
|
2226
|
+
return { recipe, label: name, what: `the ${name} recipe`, adapters: recipe.install };
|
|
2227
|
+
}
|
|
2228
|
+
async function slotPlan(slot, provider, root, opts, installed) {
|
|
2229
|
+
const label = `${slotFolder5(slot)} ${provider}`;
|
|
2230
|
+
const kind = slot === "security" ? "security adapter" : `${slotFolder5(slot)} provider`;
|
|
2231
|
+
if (!PROVIDER_NAME.test(provider)) {
|
|
2232
|
+
return fail2(`'${provider}' is no provider name: lower-case letters, digits and hyphens`);
|
|
2233
|
+
}
|
|
2234
|
+
if (provider === "custom") {
|
|
2235
|
+
return fail2("custom is an adapter you pass to createApp: there is no package to add");
|
|
2236
|
+
}
|
|
2237
|
+
if (!Object.hasOwn(ADAPTER_CATALOGUE2[slot], provider)) {
|
|
2238
|
+
const suggestion = suggestProvider(slot, provider);
|
|
2239
|
+
return fail2(
|
|
2240
|
+
suggestion === void 0 ? `unknown ${kind} '${provider}': no first-party adapter is named that; a third-party one: nymbal add <package>` : `unknown ${kind} '${provider}'; did you mean '${suggestion}'?`
|
|
2241
|
+
);
|
|
2242
|
+
}
|
|
2243
|
+
const owner = multiSlotRecipe(slot, provider);
|
|
2244
|
+
if (owner !== void 0) {
|
|
2245
|
+
const slots = MULTI_SLOT_PAIRS[owner].map((pair) => slotFolder5(pair.split("/")[0]));
|
|
2246
|
+
return fail2(`${owner} sets ${slots.join(" and ")} together: run nymbal add ${owner}`);
|
|
2247
|
+
}
|
|
2248
|
+
const what = `nymbal add ${label}`;
|
|
2249
|
+
const resolution = resolveChoice2(slot, { provider });
|
|
2250
|
+
if (resolution.kind !== "package") {
|
|
2251
|
+
const recipe2 = slotRecipe({ name: label, slot, provider, install: [], settings: [] });
|
|
2252
|
+
return { recipe: recipe2, label, what, adapters: [] };
|
|
2253
|
+
}
|
|
2254
|
+
const pkg = resolution.package;
|
|
2255
|
+
const packages = [pkg, ...resolution.sdk === void 0 ? [] : [resolution.sdk]];
|
|
2256
|
+
const failed = ensureInstalled(
|
|
2257
|
+
pkg,
|
|
2258
|
+
packages,
|
|
2259
|
+
`${label} is ${pkg}, which is not installed`,
|
|
2260
|
+
root,
|
|
2261
|
+
opts,
|
|
2262
|
+
installed
|
|
2263
|
+
);
|
|
2264
|
+
if (failed !== null) return failed;
|
|
2265
|
+
const file = packageRecipeFile(pkg, provider, root);
|
|
2266
|
+
if (file !== null) {
|
|
2267
|
+
const recipe2 = await packageRecipe(file, provider, slot);
|
|
2268
|
+
if (typeof recipe2 === "number") return recipe2;
|
|
2269
|
+
return { recipe: recipe2, label, what: `the ${recipe2.name} recipe`, adapters: recipe2.install };
|
|
2270
|
+
}
|
|
2271
|
+
let settings;
|
|
2272
|
+
try {
|
|
2273
|
+
settings = checkAdapterModule(await importFromProject(pkg, root), slot, provider, pkg).settings ?? [];
|
|
2274
|
+
} catch (error) {
|
|
2275
|
+
return fail2(
|
|
2276
|
+
error.code === "ERR_MODULE_NOT_FOUND" ? loadFailure(pkg, error, root) : messageOf(error)
|
|
2277
|
+
);
|
|
2278
|
+
}
|
|
2279
|
+
const recipe = slotRecipe({ name: label, slot, provider, install: packages, settings });
|
|
2280
|
+
return { recipe, label, what, adapters: [pkg] };
|
|
2281
|
+
}
|
|
2282
|
+
async function packagePlan(name, root, opts, installed) {
|
|
2283
|
+
const failed = ensureInstalled(name, [name], `${name} is not installed`, root, opts, installed);
|
|
2284
|
+
if (failed !== null) return failed;
|
|
2285
|
+
const refuse2 = (why) => fail2(
|
|
2286
|
+
installed.includes(name) ? `${why}
|
|
2287
|
+
${name} stays installed; ${removeLine(name, root)} removes it` : why
|
|
2288
|
+
);
|
|
2289
|
+
let mod;
|
|
2290
|
+
try {
|
|
2291
|
+
mod = await importFromProject(name, root);
|
|
2292
|
+
} catch (error) {
|
|
2293
|
+
return refuse2(loadFailure(name, error, root));
|
|
2294
|
+
}
|
|
2295
|
+
const { slot, provider } = mod;
|
|
2296
|
+
if (slot === void 0) return refuse2(`${name} exports no slot`);
|
|
2297
|
+
if (typeof slot !== "string" || !SLOTS2.includes(slot)) {
|
|
2298
|
+
return refuse2(
|
|
2299
|
+
`${name} exports slot ${show(slot)}, which is no slot; the slots are ${SLOTS2.join(", ")}`
|
|
2300
|
+
);
|
|
2301
|
+
}
|
|
2302
|
+
const at = slot;
|
|
2303
|
+
if (provider === void 0) return refuse2(`${name} exports no provider`);
|
|
2304
|
+
if (typeof provider !== "string" || !PROVIDER_NAME.test(provider)) {
|
|
2305
|
+
return refuse2(
|
|
2306
|
+
`${name} exports provider ${show(provider)}, which is no provider name: lower-case letters, digits and hyphens`
|
|
2307
|
+
);
|
|
2308
|
+
}
|
|
2309
|
+
if (provider === "custom") {
|
|
2310
|
+
return refuse2(`${name} exports provider 'custom', the name of an adapter passed to createApp`);
|
|
2311
|
+
}
|
|
2312
|
+
if (BUILT_IN[at].includes(provider)) {
|
|
2313
|
+
return refuse2(
|
|
2314
|
+
`${name} exports provider '${provider}', the name of the built-in ${slotFolder5(at)} provider`
|
|
2315
|
+
);
|
|
2316
|
+
}
|
|
2317
|
+
let settings;
|
|
2318
|
+
try {
|
|
2319
|
+
settings = checkAdapterModule(mod, at, provider, name).settings ?? [];
|
|
2320
|
+
} catch (error) {
|
|
2321
|
+
return refuse2(messageOf(error));
|
|
2322
|
+
}
|
|
2323
|
+
const file = packageRecipeFile(name, provider, root);
|
|
2324
|
+
if (file !== null) {
|
|
2325
|
+
const recipe2 = await packageRecipe(file, provider, at);
|
|
2326
|
+
if (typeof recipe2 === "number") return recipe2;
|
|
2327
|
+
return { recipe: recipe2, label: name, what: `the ${recipe2.name} recipe`, adapters: recipe2.install };
|
|
2328
|
+
}
|
|
2329
|
+
const convention = conventionPackage2(at, provider) === name;
|
|
2330
|
+
const sdk = convention ? ADAPTER_CATALOGUE2[at][provider]?.sdk : void 0;
|
|
2331
|
+
const recipe = slotRecipe({
|
|
2332
|
+
name,
|
|
2333
|
+
slot: at,
|
|
2334
|
+
provider,
|
|
2335
|
+
package: convention ? void 0 : name,
|
|
2336
|
+
install: [name, ...sdk === void 0 ? [] : [sdk]],
|
|
2337
|
+
settings
|
|
2338
|
+
});
|
|
2339
|
+
return { recipe, label: name, what: `nymbal add ${name}`, adapters: [name] };
|
|
2340
|
+
}
|
|
2341
|
+
async function add(opts, cwd = process.cwd()) {
|
|
2342
|
+
const { target } = opts;
|
|
2343
|
+
if (target.kind === "recipe" && !isKnownRecipe(target.name)) {
|
|
2344
|
+
return fail2(`unknown recipe '${target.name}'. ${usageHint()}`);
|
|
2345
|
+
}
|
|
2346
|
+
const configPath = findConfigFile2(cwd);
|
|
2347
|
+
if (configPath === null) return fail2(`no nymbal.config.ts in ${cwd} or any parent directory`);
|
|
2348
|
+
const root = dirname6(configPath);
|
|
2349
|
+
const installed = [];
|
|
2350
|
+
const plan = target.kind === "recipe" ? await recipePlan(target.name, root, opts, installed) : target.kind === "slot" ? await slotPlan(target.slot, target.provider, root, opts, installed) : await packagePlan(target.name, root, opts, installed);
|
|
2351
|
+
if (typeof plan === "number") return plan;
|
|
2352
|
+
const { recipe, label, what } = plan;
|
|
2353
|
+
const source = readFileSync4(configPath, "utf8");
|
|
1378
2354
|
let edited;
|
|
1379
2355
|
try {
|
|
1380
2356
|
const applied = applyRecipeToConfig(source, recipe, { force: opts.force });
|
|
1381
2357
|
if ("conflict" in applied) {
|
|
1382
2358
|
const { path, current, wanted } = applied.conflict;
|
|
1383
|
-
return
|
|
1384
|
-
`${path} is ${show(current)} in nymbal.config.ts, and
|
|
2359
|
+
return fail2(
|
|
2360
|
+
`${path} is ${show(current)} in nymbal.config.ts, and ${what} sets it to ${show(wanted)}. nymbal.config.ts is unchanged: edit it by hand, or re-run with --force to overwrite it.`
|
|
1385
2361
|
);
|
|
1386
2362
|
}
|
|
1387
2363
|
edited = applied;
|
|
1388
2364
|
} catch (error) {
|
|
1389
|
-
return
|
|
2365
|
+
return fail2(error.message);
|
|
1390
2366
|
}
|
|
1391
|
-
const examplePath =
|
|
1392
|
-
const example =
|
|
2367
|
+
const examplePath = join8(root, ".env.example");
|
|
2368
|
+
const example = existsSync9(examplePath) ? readFileSync4(examplePath, "utf8") : "";
|
|
1393
2369
|
const nextExample = appendRecipeEnv(example, recipe);
|
|
1394
2370
|
if (opts.dryRun) {
|
|
1395
|
-
out(
|
|
2371
|
+
out(pc5.bold(`nymbal add ${label} --dry-run: nothing is written`));
|
|
1396
2372
|
out();
|
|
1397
2373
|
out(
|
|
1398
2374
|
recipe.install.length > 0 ? `install: ${installLine(recipe.install, process.env, root)}` : "install: nothing"
|
|
@@ -1411,36 +2387,36 @@ async function add(opts, cwd = process.cwd()) {
|
|
|
1411
2387
|
const pending = recipe.install.filter((pkg) => !isInstalled(pkg, root));
|
|
1412
2388
|
if (pending.length > 0 && opts.install) {
|
|
1413
2389
|
const line = installLine(pending, process.env, root);
|
|
1414
|
-
if (!runInstall(line, root)) return
|
|
2390
|
+
if (!runInstall(line, root)) return fail2(`${line} failed`);
|
|
1415
2391
|
installed.push(...pending);
|
|
1416
2392
|
}
|
|
1417
2393
|
const fromFile = dotEnv(root);
|
|
1418
2394
|
const problems = await problemsWith(edited.source, recipe, root, fromFile);
|
|
1419
2395
|
if (problems.length > 0) {
|
|
1420
|
-
return
|
|
1421
|
-
|
|
2396
|
+
return fail2(
|
|
2397
|
+
`${what} would leave a config that does not load, so nymbal.config.ts is unchanged:
|
|
1422
2398
|
${problems.join("\n ")}`
|
|
1423
2399
|
);
|
|
1424
2400
|
}
|
|
1425
2401
|
const written = [];
|
|
1426
2402
|
if (installed.length > 0) written.push(`package.json and its lockfile (${installed.join(", ")})`);
|
|
1427
2403
|
if (edited.source !== source) {
|
|
1428
|
-
|
|
2404
|
+
writeFileSync3(configPath, edited.source);
|
|
1429
2405
|
written.push(`nymbal.config.ts (${edited.changed.join(", ")})`);
|
|
1430
2406
|
}
|
|
1431
2407
|
if (nextExample !== example) {
|
|
1432
|
-
|
|
2408
|
+
writeFileSync3(examplePath, nextExample);
|
|
1433
2409
|
written.push(
|
|
1434
2410
|
`.env.example (${missingEnv(example, recipe).map((v) => v.name).join(", ")})`
|
|
1435
2411
|
);
|
|
1436
2412
|
}
|
|
1437
|
-
out(
|
|
2413
|
+
out(pc5.green(`\u2713 ${label}: ${recipe.summary}`));
|
|
1438
2414
|
out(written.length > 0 ? ` changed ${written.join(", ")}` : " already added: nothing changed");
|
|
1439
2415
|
const unset = recipe.env.filter((v) => v.required && !isSet(v.name, fromFile));
|
|
1440
2416
|
if (unset.length > 0 || recipe.next.length > 0) {
|
|
1441
2417
|
out();
|
|
1442
2418
|
out("Next:");
|
|
1443
|
-
const fromSettings = unset.length > 0 ? await settingsEnv(
|
|
2419
|
+
const fromSettings = unset.length > 0 ? await settingsEnv(plan.adapters, root) : /* @__PURE__ */ new Set();
|
|
1444
2420
|
for (const v of unset) {
|
|
1445
2421
|
out(
|
|
1446
2422
|
fromSettings.has(v.name) ? ` - set ${v.name} in .env or in the admin's Settings` : ` - set ${v.name} in .env`
|
|
@@ -1450,13 +2426,22 @@ async function add(opts, cwd = process.cwd()) {
|
|
|
1450
2426
|
}
|
|
1451
2427
|
return 0;
|
|
1452
2428
|
}
|
|
1453
|
-
var addCommand =
|
|
2429
|
+
var addCommand = defineCommand9({
|
|
1454
2430
|
meta: {
|
|
1455
2431
|
name: "add",
|
|
1456
|
-
description:
|
|
2432
|
+
description: "Add a provider by slot, a third-party adapter by package, or a service by recipe (nymbal add lists them)"
|
|
1457
2433
|
},
|
|
1458
2434
|
args: {
|
|
1459
|
-
|
|
2435
|
+
name: {
|
|
2436
|
+
type: "positional",
|
|
2437
|
+
required: false,
|
|
2438
|
+
description: "<recipe>, <slot> or <package>"
|
|
2439
|
+
},
|
|
2440
|
+
provider: {
|
|
2441
|
+
type: "positional",
|
|
2442
|
+
required: false,
|
|
2443
|
+
description: "after <slot>: the slot's provider"
|
|
2444
|
+
},
|
|
1460
2445
|
install: {
|
|
1461
2446
|
type: "boolean",
|
|
1462
2447
|
default: true,
|
|
@@ -1465,7 +2450,7 @@ var addCommand = defineCommand7({
|
|
|
1465
2450
|
force: {
|
|
1466
2451
|
type: "boolean",
|
|
1467
2452
|
default: false,
|
|
1468
|
-
description: "Overwrite a config value the
|
|
2453
|
+
description: "Overwrite a config value the addition conflicts with"
|
|
1469
2454
|
},
|
|
1470
2455
|
"dry-run": {
|
|
1471
2456
|
type: "boolean",
|
|
@@ -1474,8 +2459,19 @@ var addCommand = defineCommand7({
|
|
|
1474
2459
|
}
|
|
1475
2460
|
},
|
|
1476
2461
|
async run({ args }) {
|
|
2462
|
+
const positionals = args._.map(String);
|
|
2463
|
+
if (positionals.length === 0) {
|
|
2464
|
+
out(addUsage());
|
|
2465
|
+
process.exitCode = 1;
|
|
2466
|
+
return;
|
|
2467
|
+
}
|
|
2468
|
+
const target = parseAddTarget(positionals);
|
|
2469
|
+
if ("error" in target) {
|
|
2470
|
+
process.exitCode = fail2(target.error);
|
|
2471
|
+
return;
|
|
2472
|
+
}
|
|
1477
2473
|
process.exitCode = await add({
|
|
1478
|
-
|
|
2474
|
+
target,
|
|
1479
2475
|
install: args.install,
|
|
1480
2476
|
force: args.force,
|
|
1481
2477
|
dryRun: args["dry-run"]
|
|
@@ -1484,13 +2480,13 @@ var addCommand = defineCommand7({
|
|
|
1484
2480
|
});
|
|
1485
2481
|
|
|
1486
2482
|
// src/commands/doctor.ts
|
|
1487
|
-
import { existsSync as
|
|
1488
|
-
import { defineCommand as
|
|
1489
|
-
import { createLogger as
|
|
2483
|
+
import { existsSync as existsSync10 } from "fs";
|
|
2484
|
+
import { defineCommand as defineCommand10 } from "citty";
|
|
2485
|
+
import { createLogger as createLogger3, diagnose } from "@nymbalhq/platform";
|
|
1490
2486
|
import { errorText, HEALTH_CHECK_TIMEOUT_MS } from "@nymbalhq/types";
|
|
1491
2487
|
|
|
1492
2488
|
// src/commands/doctor-report.ts
|
|
1493
|
-
import
|
|
2489
|
+
import pc6 from "picocolors";
|
|
1494
2490
|
import { scrub as scrubSettings } from "@nymbalhq/platform";
|
|
1495
2491
|
import { connectionSecrets, displayUrl as displayUrl2, SECRET_MIN_LENGTH } from "@nymbalhq/types";
|
|
1496
2492
|
var TEXT_STATUS = {
|
|
@@ -1505,7 +2501,7 @@ var JSON_STATUS = {
|
|
|
1505
2501
|
degraded: "degraded",
|
|
1506
2502
|
down: "down"
|
|
1507
2503
|
};
|
|
1508
|
-
var COLOUR = { ok:
|
|
2504
|
+
var COLOUR = { ok: pc6.green, warn: pc6.yellow, down: pc6.red };
|
|
1509
2505
|
var SECRET_KEY = /secret|passw(?:or)?d|^pass$|token|api[-_]?key|private[-_]?key|credential|access[-_]?key/i;
|
|
1510
2506
|
var SECRET_ENV = /SECRET|PASSWORD|PASSWD|(?:^|_)PASS(?:$|_)|TOKEN|API_KEY|PRIVATE_KEY|CREDENTIAL|ACCESS_KEY/i;
|
|
1511
2507
|
var URL_IN_TEXT = /\b[a-z][a-z0-9+.-]*:\/\/[^\s'"`<>]+/gi;
|
|
@@ -1585,9 +2581,9 @@ function timeoutOf(flag2) {
|
|
|
1585
2581
|
}
|
|
1586
2582
|
function migrationsOf(projectRoot) {
|
|
1587
2583
|
const root = resolveMigrations(projectRoot);
|
|
1588
|
-
return
|
|
2584
|
+
return existsSync10(root) ? { migrationsRoot: root } : {};
|
|
1589
2585
|
}
|
|
1590
|
-
var doctorCommand =
|
|
2586
|
+
var doctorCommand = defineCommand10({
|
|
1591
2587
|
meta: {
|
|
1592
2588
|
name: "doctor",
|
|
1593
2589
|
description: "Check the project without changing it: config, packages, command store, migrations, slots and primitives"
|
|
@@ -1613,7 +2609,7 @@ var doctorCommand = defineCommand8({
|
|
|
1613
2609
|
) : await diagnose(loaded.config, {
|
|
1614
2610
|
...loaded.adapters !== void 0 && { adapters: loaded.adapters },
|
|
1615
2611
|
// The report carries every failure; a log line would only repeat one, and break `--json`.
|
|
1616
|
-
logger:
|
|
2612
|
+
logger: createLogger3({ level: "silent", pretty: false }),
|
|
1617
2613
|
timeoutMs,
|
|
1618
2614
|
...migrationsOf(loaded.projectRoot)
|
|
1619
2615
|
});
|
|
@@ -1629,16 +2625,16 @@ var doctorCommand = defineCommand8({
|
|
|
1629
2625
|
});
|
|
1630
2626
|
|
|
1631
2627
|
// src/commands/secrets.ts
|
|
1632
|
-
import { defineCommand as
|
|
1633
|
-
import
|
|
2628
|
+
import { defineCommand as defineCommand11 } from "citty";
|
|
2629
|
+
import pc7 from "picocolors";
|
|
1634
2630
|
import {
|
|
1635
|
-
createCommandStore as
|
|
2631
|
+
createCommandStore as createCommandStore3,
|
|
1636
2632
|
createSettingsRepository,
|
|
1637
2633
|
decrypt,
|
|
1638
2634
|
encrypt,
|
|
1639
2635
|
isMissingSettingsTable,
|
|
1640
|
-
keyProblem,
|
|
1641
|
-
readSecretsKey,
|
|
2636
|
+
keyProblem as keyProblem2,
|
|
2637
|
+
readSecretsKey as readSecretsKey2,
|
|
1642
2638
|
SECRETS_KEY_ENV,
|
|
1643
2639
|
SECRETS_KEY_OLD_ENV,
|
|
1644
2640
|
settingAad
|
|
@@ -1646,17 +2642,17 @@ import {
|
|
|
1646
2642
|
var RotationRefused = class extends Error {
|
|
1647
2643
|
};
|
|
1648
2644
|
function refuse(message) {
|
|
1649
|
-
process.stderr.write(`${
|
|
2645
|
+
process.stderr.write(`${pc7.red(`\u2717 ${message}`)}
|
|
1650
2646
|
`);
|
|
1651
2647
|
process.exitCode = 2;
|
|
1652
2648
|
}
|
|
1653
2649
|
async function rotateSecrets(env = process.env) {
|
|
1654
|
-
const oldKey =
|
|
1655
|
-
if (!oldKey.ok) throw new RotationRefused(
|
|
1656
|
-
const newKey =
|
|
1657
|
-
if (!newKey.ok) throw new RotationRefused(
|
|
2650
|
+
const oldKey = readSecretsKey2(env, SECRETS_KEY_OLD_ENV);
|
|
2651
|
+
if (!oldKey.ok) throw new RotationRefused(keyProblem2(oldKey.reason, SECRETS_KEY_OLD_ENV));
|
|
2652
|
+
const newKey = readSecretsKey2(env, SECRETS_KEY_ENV);
|
|
2653
|
+
if (!newKey.ok) throw new RotationRefused(keyProblem2(newKey.reason, SECRETS_KEY_ENV));
|
|
1658
2654
|
const { config } = await loadProject();
|
|
1659
|
-
const store =
|
|
2655
|
+
const store = createCommandStore3(config);
|
|
1660
2656
|
try {
|
|
1661
2657
|
const repo = createSettingsRepository(store);
|
|
1662
2658
|
return await store.transaction(async (tx) => {
|
|
@@ -1690,7 +2686,7 @@ async function rotateSecrets(env = process.env) {
|
|
|
1690
2686
|
}
|
|
1691
2687
|
async function clearSecrets(filter) {
|
|
1692
2688
|
const { config } = await loadProject();
|
|
1693
|
-
const store =
|
|
2689
|
+
const store = createCommandStore3(config);
|
|
1694
2690
|
try {
|
|
1695
2691
|
const repo = createSettingsRepository(store);
|
|
1696
2692
|
return await store.transaction((tx) => repo.clear(tx, filter));
|
|
@@ -1701,7 +2697,7 @@ async function clearSecrets(filter) {
|
|
|
1701
2697
|
await store.close();
|
|
1702
2698
|
}
|
|
1703
2699
|
}
|
|
1704
|
-
var rotateCommand =
|
|
2700
|
+
var rotateCommand = defineCommand11({
|
|
1705
2701
|
meta: {
|
|
1706
2702
|
name: "rotate",
|
|
1707
2703
|
description: `Re-encrypt every saved secret from ${SECRETS_KEY_OLD_ENV} to ${SECRETS_KEY_ENV}, all or none`
|
|
@@ -1710,7 +2706,7 @@ var rotateCommand = defineCommand9({
|
|
|
1710
2706
|
try {
|
|
1711
2707
|
const count = await rotateSecrets();
|
|
1712
2708
|
process.stdout.write(
|
|
1713
|
-
`${
|
|
2709
|
+
`${pc7.green(`\u2713 rotated ${count} secret${count === 1 ? "" : "s"} to ${SECRETS_KEY_ENV}`)}
|
|
1714
2710
|
`
|
|
1715
2711
|
);
|
|
1716
2712
|
} catch (error) {
|
|
@@ -1718,7 +2714,7 @@ var rotateCommand = defineCommand9({
|
|
|
1718
2714
|
}
|
|
1719
2715
|
}
|
|
1720
2716
|
});
|
|
1721
|
-
var clearCommand =
|
|
2717
|
+
var clearCommand = defineCommand11({
|
|
1722
2718
|
meta: {
|
|
1723
2719
|
name: "clear",
|
|
1724
2720
|
description: "Delete saved settings (all, or one slot or path); needs no key"
|
|
@@ -1733,22 +2729,22 @@ var clearCommand = defineCommand9({
|
|
|
1733
2729
|
...args.path !== void 0 && { path: args.path }
|
|
1734
2730
|
});
|
|
1735
2731
|
process.stdout.write(
|
|
1736
|
-
`${
|
|
2732
|
+
`${pc7.green(`\u2713 cleared ${count} setting${count === 1 ? "" : "s"}`)}; restart the store to apply
|
|
1737
2733
|
`
|
|
1738
2734
|
);
|
|
1739
2735
|
}
|
|
1740
2736
|
});
|
|
1741
|
-
var secretsCommand =
|
|
2737
|
+
var secretsCommand = defineCommand11({
|
|
1742
2738
|
meta: { name: "secrets", description: "Manage the values saved in the admin's Settings" },
|
|
1743
2739
|
subCommands: { rotate: rotateCommand, clear: clearCommand }
|
|
1744
2740
|
});
|
|
1745
2741
|
|
|
1746
2742
|
// src/commands/events.ts
|
|
1747
|
-
import { existsSync as
|
|
1748
|
-
import { resolve as
|
|
1749
|
-
import { defineCommand as
|
|
2743
|
+
import { existsSync as existsSync11 } from "fs";
|
|
2744
|
+
import { resolve as resolve7 } from "path";
|
|
2745
|
+
import { defineCommand as defineCommand12 } from "citty";
|
|
1750
2746
|
import {
|
|
1751
|
-
createCommandStore as
|
|
2747
|
+
createCommandStore as createCommandStore4,
|
|
1752
2748
|
createEventLogRepository,
|
|
1753
2749
|
sqliteFile as sqliteFile2
|
|
1754
2750
|
} from "@nymbalhq/platform";
|
|
@@ -1768,7 +2764,9 @@ function formatEvent(row2, opts) {
|
|
|
1768
2764
|
...envelope,
|
|
1769
2765
|
...opts.payload && { payload },
|
|
1770
2766
|
seq: row2.seq,
|
|
1771
|
-
deliveredAt: row2.deliveredAt
|
|
2767
|
+
deliveredAt: row2.deliveredAt,
|
|
2768
|
+
attempts: row2.attempts,
|
|
2769
|
+
deadAt: row2.deadAt
|
|
1772
2770
|
});
|
|
1773
2771
|
}
|
|
1774
2772
|
function timeFlag(name, value) {
|
|
@@ -1796,11 +2794,11 @@ async function openLog() {
|
|
|
1796
2794
|
const { config } = await loadProject();
|
|
1797
2795
|
if (config.infrastructure.commandStore === "sqlite") {
|
|
1798
2796
|
const path = sqliteFile2();
|
|
1799
|
-
if (!
|
|
2797
|
+
if (!existsSync11(resolve7(path))) {
|
|
1800
2798
|
throw new EventsError(`no database at ${path}: run \`nymbal migrate\``);
|
|
1801
2799
|
}
|
|
1802
2800
|
}
|
|
1803
|
-
const store =
|
|
2801
|
+
const store = createCommandStore4(config, { readOnly: true });
|
|
1804
2802
|
return { store, eventLog: createEventLogRepository(store) };
|
|
1805
2803
|
}
|
|
1806
2804
|
async function guarded(body) {
|
|
@@ -1829,7 +2827,7 @@ var outputArgs = {
|
|
|
1829
2827
|
default: false
|
|
1830
2828
|
}
|
|
1831
2829
|
};
|
|
1832
|
-
var queryCommand =
|
|
2830
|
+
var queryCommand = defineCommand12({
|
|
1833
2831
|
meta: { name: "query", description: "Print one correlation id\u2019s events, in seq order" },
|
|
1834
2832
|
args: {
|
|
1835
2833
|
correlation: { type: "string", description: "The correlation id (required)" },
|
|
@@ -1866,7 +2864,7 @@ var queryCommand = defineCommand10({
|
|
|
1866
2864
|
}
|
|
1867
2865
|
})
|
|
1868
2866
|
});
|
|
1869
|
-
var tailCommand =
|
|
2867
|
+
var tailCommand = defineCommand12({
|
|
1870
2868
|
meta: {
|
|
1871
2869
|
name: "tail",
|
|
1872
2870
|
description: "Print events as they are appended, until interrupted. Exact for serially committed events; on Postgres an event whose lower seq commits after a higher one has been printed is skipped."
|
|
@@ -1922,19 +2920,19 @@ var tailCommand = defineCommand10({
|
|
|
1922
2920
|
}
|
|
1923
2921
|
})
|
|
1924
2922
|
});
|
|
1925
|
-
var eventsCommand =
|
|
2923
|
+
var eventsCommand = defineCommand12({
|
|
1926
2924
|
meta: { name: "events", description: "Read the event log without changing it" },
|
|
1927
2925
|
subCommands: { query: queryCommand, tail: tailCommand }
|
|
1928
2926
|
});
|
|
1929
2927
|
|
|
1930
2928
|
// src/commands/audit.ts
|
|
1931
|
-
import { createWriteStream, existsSync as
|
|
1932
|
-
import { resolve as
|
|
2929
|
+
import { createWriteStream, existsSync as existsSync12 } from "fs";
|
|
2930
|
+
import { resolve as resolve8 } from "path";
|
|
1933
2931
|
import { once } from "events";
|
|
1934
|
-
import { defineCommand as
|
|
2932
|
+
import { defineCommand as defineCommand13 } from "citty";
|
|
1935
2933
|
import {
|
|
1936
2934
|
auditEntriesInOrder,
|
|
1937
|
-
createCommandStore as
|
|
2935
|
+
createCommandStore as createCommandStore5,
|
|
1938
2936
|
sqliteFile as sqliteFile3
|
|
1939
2937
|
} from "@nymbalhq/platform";
|
|
1940
2938
|
import { errorText as errorText3 } from "@nymbalhq/types";
|
|
@@ -1951,7 +2949,7 @@ function timeFlag2(name, value) {
|
|
|
1951
2949
|
async function write2(out2, text2) {
|
|
1952
2950
|
if (!out2.write(text2)) await once(out2, "drain");
|
|
1953
2951
|
}
|
|
1954
|
-
var exportCommand =
|
|
2952
|
+
var exportCommand = defineCommand13({
|
|
1955
2953
|
meta: {
|
|
1956
2954
|
name: "export",
|
|
1957
2955
|
description: "Print audit entries as NDJSON, oldest first: ids only, no event payloads or customer data"
|
|
@@ -1974,11 +2972,11 @@ var exportCommand = defineCommand11({
|
|
|
1974
2972
|
const { config } = await loadProject();
|
|
1975
2973
|
if (config.infrastructure.commandStore === "sqlite") {
|
|
1976
2974
|
const path = sqliteFile3();
|
|
1977
|
-
if (!
|
|
2975
|
+
if (!existsSync12(resolve8(path))) {
|
|
1978
2976
|
throw new AuditError(`no database at ${path}: run \`nymbal migrate\``);
|
|
1979
2977
|
}
|
|
1980
2978
|
}
|
|
1981
|
-
const store =
|
|
2979
|
+
const store = createCommandStore5(config, { readOnly: true });
|
|
1982
2980
|
const out2 = args.out === void 0 ? process.stdout : createWriteStream(args.out);
|
|
1983
2981
|
try {
|
|
1984
2982
|
for await (const entry of auditEntriesInOrder(store, filter)) {
|
|
@@ -1999,17 +2997,17 @@ var exportCommand = defineCommand11({
|
|
|
1999
2997
|
}
|
|
2000
2998
|
}
|
|
2001
2999
|
});
|
|
2002
|
-
var auditCommand =
|
|
3000
|
+
var auditCommand = defineCommand13({
|
|
2003
3001
|
meta: { name: "audit", description: "Read the audit trail" },
|
|
2004
3002
|
subCommands: { export: exportCommand }
|
|
2005
3003
|
});
|
|
2006
3004
|
|
|
2007
3005
|
// src/commands/replay.ts
|
|
2008
|
-
import { existsSync as
|
|
2009
|
-
import { resolve as
|
|
2010
|
-
import { defineCommand as
|
|
3006
|
+
import { existsSync as existsSync13 } from "fs";
|
|
3007
|
+
import { resolve as resolve9 } from "path";
|
|
3008
|
+
import { defineCommand as defineCommand14 } from "citty";
|
|
2011
3009
|
import {
|
|
2012
|
-
createLogger as
|
|
3010
|
+
createLogger as createLogger4,
|
|
2013
3011
|
diffReadModel,
|
|
2014
3012
|
openReadModels,
|
|
2015
3013
|
READ_MODEL_NAMES,
|
|
@@ -2059,15 +3057,15 @@ function write3(stream, text2) {
|
|
|
2059
3057
|
return new Promise((done) => stream.write(`${text2}
|
|
2060
3058
|
`, () => done()));
|
|
2061
3059
|
}
|
|
2062
|
-
var replayCommand =
|
|
3060
|
+
var replayCommand = defineCommand14({
|
|
2063
3061
|
meta: {
|
|
2064
3062
|
name: "replay",
|
|
2065
|
-
description: "Rebuild a derived read model from the command store and swap it in: catalogue, orders, customers, search or all"
|
|
3063
|
+
description: "Rebuild a derived read model from the command store and swap it in: catalogue, orders, customers, search, recently-viewed or all"
|
|
2066
3064
|
},
|
|
2067
3065
|
args: {
|
|
2068
3066
|
to: {
|
|
2069
3067
|
type: "string",
|
|
2070
|
-
description: "The read model: catalogue, orders, customers, search or all"
|
|
3068
|
+
description: "The read model: catalogue, orders, customers, search, recently-viewed or all"
|
|
2071
3069
|
},
|
|
2072
3070
|
"dry-run": {
|
|
2073
3071
|
type: "boolean",
|
|
@@ -2080,17 +3078,17 @@ var replayCommand = defineCommand12({
|
|
|
2080
3078
|
const names = modelsOf(args.to);
|
|
2081
3079
|
const { config, adapters } = await loadProject();
|
|
2082
3080
|
const shared = names.filter((n) => n !== "search");
|
|
2083
|
-
if (config.infrastructure.documentStore === "in-memory" && shared.length > 0) {
|
|
3081
|
+
if (config.infrastructure.documentStore.provider === "in-memory" && shared.length > 0) {
|
|
2084
3082
|
throw new ReplayError(
|
|
2085
|
-
`the ${shared.join(", ")} read model${shared.length === 1 ? "" : "s"} live in the server's own process (documentStore
|
|
3083
|
+
`the ${shared.join(", ")} read model${shared.length === 1 ? "" : "s"} live in the server's own process (infrastructure.documentStore 'in-memory'), out of reach of this one; a restart of the server rebuilds them. With infrastructure.documentStore redis or postgres-jsonb the read models are shared, and replay rebuilds them in place. --to search works here: the native index lives in the command store.`
|
|
2086
3084
|
);
|
|
2087
3085
|
}
|
|
2088
|
-
if (config.infrastructure.commandStore === "sqlite" && !
|
|
3086
|
+
if (config.infrastructure.commandStore === "sqlite" && !existsSync13(resolve9(sqliteFile4()))) {
|
|
2089
3087
|
throw new ReplayError(`no database at ${sqliteFile4()}: run \`nymbal migrate\``);
|
|
2090
3088
|
}
|
|
2091
3089
|
const { deps, close } = await openReadModels(config, {
|
|
2092
3090
|
// The report says what happened; log lines would repeat it.
|
|
2093
|
-
logger:
|
|
3091
|
+
logger: createLogger4({ level: "silent", pretty: false }),
|
|
2094
3092
|
...adapters !== void 0 && { adapters }
|
|
2095
3093
|
});
|
|
2096
3094
|
try {
|
|
@@ -2115,8 +3113,8 @@ var replayCommand = defineCommand12({
|
|
|
2115
3113
|
});
|
|
2116
3114
|
|
|
2117
3115
|
// src/commands/security.ts
|
|
2118
|
-
import { defineCommand as
|
|
2119
|
-
import { createLogger as
|
|
3116
|
+
import { defineCommand as defineCommand15 } from "citty";
|
|
3117
|
+
import { createLogger as createLogger5, importAdapterModule } from "@nymbalhq/platform";
|
|
2120
3118
|
import {
|
|
2121
3119
|
errorText as errorText5
|
|
2122
3120
|
} from "@nymbalhq/types";
|
|
@@ -2172,15 +3170,18 @@ async function runEdge(command, body) {
|
|
|
2172
3170
|
`security.adapter is '${security.adapter}', which has no edge rules for nymbal ${command}: set security.adapter to 'cloudflare' (nymbal add cloudflare) to manage them on a Cloudflare zone`
|
|
2173
3171
|
);
|
|
2174
3172
|
} else {
|
|
2175
|
-
const mod = await
|
|
3173
|
+
const mod = await importAdapterModule(
|
|
2176
3174
|
"security",
|
|
2177
|
-
|
|
3175
|
+
{
|
|
3176
|
+
provider: "cloudflare",
|
|
3177
|
+
...security.package !== void 0 && { package: security.package }
|
|
3178
|
+
},
|
|
2178
3179
|
process.env
|
|
2179
3180
|
);
|
|
2180
3181
|
const adapter = await mod.createAdapter({
|
|
2181
3182
|
slot: "security",
|
|
2182
3183
|
config: security.cloudflare ?? {},
|
|
2183
|
-
logger:
|
|
3184
|
+
logger: createLogger5({ level: "silent", pretty: false }),
|
|
2184
3185
|
env: process.env
|
|
2185
3186
|
});
|
|
2186
3187
|
outcome = await body(adapter, security, mod);
|
|
@@ -2198,7 +3199,7 @@ var json = {
|
|
|
2198
3199
|
description: "Print the result as one JSON document",
|
|
2199
3200
|
default: false
|
|
2200
3201
|
};
|
|
2201
|
-
var securityPlanCommand =
|
|
3202
|
+
var securityPlanCommand = defineCommand15({
|
|
2202
3203
|
meta: {
|
|
2203
3204
|
name: "security:plan",
|
|
2204
3205
|
description: "Show what security:apply would change on the Cloudflare zone"
|
|
@@ -2214,7 +3215,7 @@ var securityPlanCommand = defineCommand13({
|
|
|
2214
3215
|
return { code: 0, stdout: [...lines, ...notes], stderr: [] };
|
|
2215
3216
|
})
|
|
2216
3217
|
});
|
|
2217
|
-
var securityApplyCommand =
|
|
3218
|
+
var securityApplyCommand = defineCommand15({
|
|
2218
3219
|
meta: {
|
|
2219
3220
|
name: "security:apply",
|
|
2220
3221
|
description: "Write the store's security rules to the Cloudflare zone, leaving the zone's own rules"
|
|
@@ -2227,7 +3228,7 @@ var securityApplyCommand = defineCommand13({
|
|
|
2227
3228
|
return { code: 0, stdout: lines, stderr: [] };
|
|
2228
3229
|
})
|
|
2229
3230
|
});
|
|
2230
|
-
var securityDriftCommand =
|
|
3231
|
+
var securityDriftCommand = defineCommand15({
|
|
2231
3232
|
meta: {
|
|
2232
3233
|
name: "security:drift",
|
|
2233
3234
|
description: "Report where the zone's Nymbal rules differ from the config (exit 1 on drift)"
|
|
@@ -2252,7 +3253,7 @@ var securityDriftCommand = defineCommand13({
|
|
|
2252
3253
|
};
|
|
2253
3254
|
})
|
|
2254
3255
|
});
|
|
2255
|
-
var securityInspectCommand =
|
|
3256
|
+
var securityInspectCommand = defineCommand15({
|
|
2256
3257
|
meta: {
|
|
2257
3258
|
name: "security:inspect",
|
|
2258
3259
|
description: "List the Nymbal rules live on the Cloudflare zone"
|
|
@@ -2265,53 +3266,69 @@ var securityInspectCommand = defineCommand13({
|
|
|
2265
3266
|
});
|
|
2266
3267
|
|
|
2267
3268
|
// src/commands/test.ts
|
|
2268
|
-
import { defineCommand as
|
|
3269
|
+
import { defineCommand as defineCommand16 } from "citty";
|
|
2269
3270
|
import { loadConfig as loadConfig4 } from "@nymbalhq/config";
|
|
2270
3271
|
|
|
2271
3272
|
// src/commands/test-contracts.ts
|
|
2272
|
-
import { mkdirSync, realpathSync, writeFileSync as
|
|
2273
|
-
import { createRequire as
|
|
2274
|
-
import { dirname as dirname7, join as
|
|
2275
|
-
import { pathToFileURL as
|
|
3273
|
+
import { mkdirSync, realpathSync, writeFileSync as writeFileSync4 } from "fs";
|
|
3274
|
+
import { createRequire as createRequire4 } from "module";
|
|
3275
|
+
import { dirname as dirname7, join as join9, resolve as resolve10 } from "path";
|
|
3276
|
+
import { pathToFileURL as pathToFileURL3 } from "url";
|
|
2276
3277
|
import { isDeepStrictEqual } from "util";
|
|
2277
|
-
import { findConfigFile as findConfigFile3, loadConfig as loadConfig3 } from "@nymbalhq/config";
|
|
3278
|
+
import { findConfigFile as findConfigFile3, loadConfig as loadConfig3, slotFolder as slotFolder6 } from "@nymbalhq/config";
|
|
3279
|
+
import { checkAdapterModule as checkAdapterModule2, resolveChoice as resolveChoice3 } from "@nymbalhq/platform";
|
|
2278
3280
|
var CertifyError = class extends Error {
|
|
2279
3281
|
};
|
|
2280
3282
|
var firstLine = (text2) => text2.split("\n")[0].trim();
|
|
2281
|
-
var
|
|
2282
|
-
function
|
|
3283
|
+
var messageOf2 = (err2) => firstLine(err2 instanceof Error ? err2.message : String(err2));
|
|
3284
|
+
function resolveFrom2(project, specifier, name, install) {
|
|
2283
3285
|
try {
|
|
2284
|
-
return
|
|
3286
|
+
return createRequire4(join9(project, "package.json")).resolve(specifier);
|
|
2285
3287
|
} catch (err2) {
|
|
2286
3288
|
if (err2.code === "MODULE_NOT_FOUND") {
|
|
2287
3289
|
throw new CertifyError(`${name} is not installed in ${project}: ${install}`);
|
|
2288
3290
|
}
|
|
2289
|
-
throw new CertifyError(`${name} could not be resolved from ${project}: ${
|
|
3291
|
+
throw new CertifyError(`${name} could not be resolved from ${project}: ${messageOf2(err2)}`);
|
|
2290
3292
|
}
|
|
2291
3293
|
}
|
|
2292
|
-
|
|
3294
|
+
function slotBlocks(config) {
|
|
3295
|
+
const { commerce, infrastructure, security } = config;
|
|
3296
|
+
const slots = Object.entries(commerce).filter(([name]) => name !== "orders");
|
|
3297
|
+
return [
|
|
3298
|
+
...slots,
|
|
3299
|
+
["documentStore", infrastructure.documentStore],
|
|
3300
|
+
["eventBus", infrastructure.eventBus],
|
|
3301
|
+
["media", infrastructure.media],
|
|
3302
|
+
[
|
|
3303
|
+
"security",
|
|
3304
|
+
{ provider: security.adapter, package: security.package, config: security.config }
|
|
3305
|
+
]
|
|
3306
|
+
];
|
|
3307
|
+
}
|
|
3308
|
+
async function pickSlot(project, pkg, slot) {
|
|
2293
3309
|
if (findConfigFile3(project) === null) return void 0;
|
|
2294
|
-
let
|
|
3310
|
+
let config;
|
|
2295
3311
|
try {
|
|
2296
|
-
|
|
3312
|
+
config = (await loadConfig3(project)).config;
|
|
2297
3313
|
} catch (err2) {
|
|
2298
|
-
throw new CertifyError(`the project's config could not be loaded: ${
|
|
3314
|
+
throw new CertifyError(`the project's config could not be loaded: ${messageOf2(err2)}`);
|
|
2299
3315
|
}
|
|
2300
|
-
const naming =
|
|
2301
|
-
const
|
|
2302
|
-
return
|
|
3316
|
+
const naming = slotBlocks(config).filter(([name, block]) => {
|
|
3317
|
+
const resolved = resolveChoice3(name, block);
|
|
3318
|
+
return block.package === pkg || resolved.kind === "package" && resolved.package === pkg;
|
|
2303
3319
|
});
|
|
2304
|
-
const
|
|
3320
|
+
const wanted = slot === void 0 ? void 0 : slotNamed(slot);
|
|
3321
|
+
const picked = slot === void 0 ? naming : naming.filter(([name]) => name === wanted);
|
|
2305
3322
|
if (slot !== void 0 && picked.length === 0) {
|
|
2306
|
-
throw new CertifyError(`no
|
|
3323
|
+
throw new CertifyError(`no slot '${slot}' loads ${pkg}`);
|
|
2307
3324
|
}
|
|
2308
3325
|
if (picked.length > 1) {
|
|
2309
3326
|
throw new CertifyError(
|
|
2310
|
-
`${pkg} is named by the ${picked.map(([name]) => name).join(", ")} slots: pick one with --slot`
|
|
3327
|
+
`${pkg} is named by the ${picked.map(([name]) => slotFolder6(name)).join(", ")} slots: pick one with --slot`
|
|
2311
3328
|
);
|
|
2312
3329
|
}
|
|
2313
|
-
const
|
|
2314
|
-
return
|
|
3330
|
+
const found = picked[0];
|
|
3331
|
+
return found === void 0 ? void 0 : { slot: found[0], block: found[1] };
|
|
2315
3332
|
}
|
|
2316
3333
|
function withoutUndefined(value, path = /* @__PURE__ */ new Set()) {
|
|
2317
3334
|
if (value === null || typeof value !== "object" || path.has(value)) return value;
|
|
@@ -2351,9 +3368,9 @@ function countCases(files) {
|
|
|
2351
3368
|
async function certifyPackage(input) {
|
|
2352
3369
|
const { pkg, slot } = input;
|
|
2353
3370
|
const config = findConfigFile3(input.cwd);
|
|
2354
|
-
const project = realpathSync(config === null ?
|
|
2355
|
-
const vitestNode =
|
|
2356
|
-
const kindsEntry =
|
|
3371
|
+
const project = realpathSync(config === null ? resolve10(input.cwd) : dirname7(config));
|
|
3372
|
+
const vitestNode = resolveFrom2(project, "vitest/node", "vitest", "npm install --save-dev vitest");
|
|
3373
|
+
const kindsEntry = resolveFrom2(
|
|
2357
3374
|
project,
|
|
2358
3375
|
"@nymbalhq/contract-tests/kinds",
|
|
2359
3376
|
"@nymbalhq/contract-tests",
|
|
@@ -2362,24 +3379,31 @@ async function certifyPackage(input) {
|
|
|
2362
3379
|
if (!isInstalled(pkg, project)) {
|
|
2363
3380
|
throw new CertifyError(`${pkg} is not installed in ${project}: npm install ${pkg}`);
|
|
2364
3381
|
}
|
|
2365
|
-
const contracts =
|
|
3382
|
+
const contracts = join9(project, ".nymbal", "contracts");
|
|
2366
3383
|
const slug = pkg.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "");
|
|
2367
3384
|
mkdirSync(contracts, { recursive: true });
|
|
2368
|
-
const shim =
|
|
2369
|
-
|
|
3385
|
+
const shim = join9(contracts, `${slug}.adapter.mjs`);
|
|
3386
|
+
writeFileSync4(shim, `export * from ${JSON.stringify(pkg)}
|
|
2370
3387
|
`);
|
|
2371
3388
|
let mod;
|
|
2372
3389
|
try {
|
|
2373
|
-
mod = await import(
|
|
3390
|
+
mod = await import(pathToFileURL3(shim).href);
|
|
2374
3391
|
} catch (err2) {
|
|
2375
|
-
throw new CertifyError(`${pkg} could not be loaded: ${
|
|
3392
|
+
throw new CertifyError(`${pkg} could not be loaded: ${messageOf2(err2)}`);
|
|
2376
3393
|
}
|
|
2377
|
-
|
|
3394
|
+
const picked = await pickSlot(project, pkg, slot);
|
|
3395
|
+
if (picked !== void 0) {
|
|
3396
|
+
try {
|
|
3397
|
+
checkAdapterModule2(mod, picked.slot, picked.block.provider, pkg);
|
|
3398
|
+
} catch (err2) {
|
|
3399
|
+
throw new CertifyError(messageOf2(err2));
|
|
3400
|
+
}
|
|
3401
|
+
} else if (typeof mod.createAdapter !== "function") {
|
|
2378
3402
|
throw new CertifyError(`${pkg} exports no createAdapter(options) function to certify`);
|
|
2379
3403
|
}
|
|
2380
3404
|
const createAdapter = mod.createAdapter;
|
|
2381
3405
|
const extra = mod.contractOptions ?? {};
|
|
2382
|
-
const slotConfig =
|
|
3406
|
+
const slotConfig = picked === void 0 ? void 0 : picked.block.config ?? {};
|
|
2383
3407
|
const fromSlot = slotConfig === void 0 ? void 0 : withoutUndefined(slotConfig);
|
|
2384
3408
|
const options = fromSlot ?? extra.options ?? {};
|
|
2385
3409
|
if (fromSlot !== void 0 && !survivesJson(fromSlot)) {
|
|
@@ -2394,22 +3418,22 @@ async function certifyPackage(input) {
|
|
|
2394
3418
|
kind = typeof own === "string" ? own : extra.kind;
|
|
2395
3419
|
await closeProbe(probe);
|
|
2396
3420
|
} catch (err2) {
|
|
2397
|
-
throw new CertifyError(`createAdapter from ${pkg} threw: ${
|
|
3421
|
+
throw new CertifyError(`createAdapter from ${pkg} threw: ${messageOf2(err2)}`);
|
|
2398
3422
|
}
|
|
2399
3423
|
if (kind === void 0) {
|
|
2400
3424
|
throw new CertifyError(
|
|
2401
3425
|
`${pkg}'s adapter has no kind: a primitive names its own in contractOptions.kind`
|
|
2402
3426
|
);
|
|
2403
3427
|
}
|
|
2404
|
-
const { CONTRACT_KINDS } = await import(
|
|
3428
|
+
const { CONTRACT_KINDS } = await import(pathToFileURL3(kindsEntry).href);
|
|
2405
3429
|
if (!CONTRACT_KINDS.includes(kind)) {
|
|
2406
3430
|
throw new CertifyError(
|
|
2407
3431
|
`no contract suite for kind '${kind}' (${pkg}); the kinds with one are ${CONTRACT_KINDS.join(", ")}`
|
|
2408
3432
|
);
|
|
2409
3433
|
}
|
|
2410
3434
|
const file = `${slug}.contract.test.mjs`;
|
|
2411
|
-
|
|
2412
|
-
|
|
3435
|
+
writeFileSync4(
|
|
3436
|
+
join9(contracts, file),
|
|
2413
3437
|
[
|
|
2414
3438
|
`// Written by \`nymbal test:contracts --package ${pkg}\`, and again on every run.`,
|
|
2415
3439
|
`import * as adapter from ${JSON.stringify(pkg)}`,
|
|
@@ -2430,7 +3454,7 @@ async function certifyPackage(input) {
|
|
|
2430
3454
|
``
|
|
2431
3455
|
].join("\n")
|
|
2432
3456
|
);
|
|
2433
|
-
const { startVitest } = await import(
|
|
3457
|
+
const { startVitest } = await import(pathToFileURL3(vitestNode).href);
|
|
2434
3458
|
const vitest = await startVitest(
|
|
2435
3459
|
"test",
|
|
2436
3460
|
[],
|
|
@@ -2442,7 +3466,7 @@ async function certifyPackage(input) {
|
|
|
2442
3466
|
testTimeout: 6e4,
|
|
2443
3467
|
hookTimeout: 6e4
|
|
2444
3468
|
},
|
|
2445
|
-
{ cacheDir:
|
|
3469
|
+
{ cacheDir: join9(contracts, ".vite") }
|
|
2446
3470
|
);
|
|
2447
3471
|
if (vitest === void 0) throw new CertifyError(`vitest did not start for ${pkg}`);
|
|
2448
3472
|
const files = vitest.state.getFiles();
|
|
@@ -2461,13 +3485,13 @@ async function certifyPackage(input) {
|
|
|
2461
3485
|
}
|
|
2462
3486
|
|
|
2463
3487
|
// src/commands/test.ts
|
|
2464
|
-
var testCommand =
|
|
3488
|
+
var testCommand = defineCommand16({
|
|
2465
3489
|
meta: { name: "test", description: "Run unit + integration tests (vitest)" },
|
|
2466
3490
|
async run() {
|
|
2467
3491
|
await runOrFail("pnpm", ["vitest", "run"]);
|
|
2468
3492
|
}
|
|
2469
3493
|
});
|
|
2470
|
-
var testE2eCommand =
|
|
3494
|
+
var testE2eCommand = defineCommand16({
|
|
2471
3495
|
meta: { name: "test:e2e", description: "Run Playwright E2E against the configured template" },
|
|
2472
3496
|
async run() {
|
|
2473
3497
|
const { config } = await loadConfig4();
|
|
@@ -2484,7 +3508,7 @@ var testE2eCommand = defineCommand14({
|
|
|
2484
3508
|
]);
|
|
2485
3509
|
}
|
|
2486
3510
|
});
|
|
2487
|
-
var testVisualCommand =
|
|
3511
|
+
var testVisualCommand = defineCommand16({
|
|
2488
3512
|
meta: { name: "test:visual", description: "Run visual regression tests (Playwright toHaveScreenshot)" },
|
|
2489
3513
|
args: {
|
|
2490
3514
|
"update-baselines": {
|
|
@@ -2529,7 +3553,7 @@ var testVisualCommand = defineCommand14({
|
|
|
2529
3553
|
}
|
|
2530
3554
|
}
|
|
2531
3555
|
});
|
|
2532
|
-
var testContractsCommand =
|
|
3556
|
+
var testContractsCommand = defineCommand16({
|
|
2533
3557
|
meta: { name: "test:contracts", description: "Run adapter contract tests, or certify an adapter package" },
|
|
2534
3558
|
args: {
|
|
2535
3559
|
adapter: { type: "string", description: "Run only contracts for a specific adapter (e.g. payments, email)" },
|
|
@@ -2570,7 +3594,7 @@ var testContractsCommand = defineCommand14({
|
|
|
2570
3594
|
await runOrFail("pnpm", vArgs);
|
|
2571
3595
|
}
|
|
2572
3596
|
});
|
|
2573
|
-
var testPerformanceCommand =
|
|
3597
|
+
var testPerformanceCommand = defineCommand16({
|
|
2574
3598
|
meta: { name: "test:performance", description: "Run Lighthouse CI against the configured template" },
|
|
2575
3599
|
async run() {
|
|
2576
3600
|
const { config } = await loadConfig4();
|
|
@@ -2584,7 +3608,7 @@ var testPerformanceCommand = defineCommand14({
|
|
|
2584
3608
|
});
|
|
2585
3609
|
}
|
|
2586
3610
|
});
|
|
2587
|
-
var testAllCommand =
|
|
3611
|
+
var testAllCommand = defineCommand16({
|
|
2588
3612
|
meta: { name: "test:all", description: "Run unit, contract, e2e, visual, and performance tests" },
|
|
2589
3613
|
async run() {
|
|
2590
3614
|
const steps = [
|
|
@@ -2629,7 +3653,7 @@ var testAllCommand = defineCommand14({
|
|
|
2629
3653
|
});
|
|
2630
3654
|
|
|
2631
3655
|
// src/index.ts
|
|
2632
|
-
var main =
|
|
3656
|
+
var main = defineCommand17({
|
|
2633
3657
|
meta: {
|
|
2634
3658
|
name: "nymbal",
|
|
2635
3659
|
version: getCliVersion(),
|
|
@@ -2638,6 +3662,8 @@ var main = defineCommand15({
|
|
|
2638
3662
|
subCommands: {
|
|
2639
3663
|
dev: devCommand,
|
|
2640
3664
|
build: buildCommand,
|
|
3665
|
+
start: startCommand,
|
|
3666
|
+
deploy: deployCommand,
|
|
2641
3667
|
migrate: migrateCommand,
|
|
2642
3668
|
seed: seedCommand,
|
|
2643
3669
|
import: importCommand,
|
|
@@ -2665,7 +3691,14 @@ if (rest.length === 0 && (flag === "--version" || flag === "-v")) {
|
|
|
2665
3691
|
process.stdout.write(`${getCliVersion()}
|
|
2666
3692
|
`);
|
|
2667
3693
|
} else {
|
|
2668
|
-
runMain(main
|
|
3694
|
+
runMain(main, {
|
|
3695
|
+
// `nymbal add --help` lists the forms, the slots with their providers, and the recipes.
|
|
3696
|
+
showUsage: async (cmd, parent) => {
|
|
3697
|
+
await showUsage(cmd, parent);
|
|
3698
|
+
if (cmd === addCommand) process.stdout.write(`${addUsage()}
|
|
3699
|
+
`);
|
|
3700
|
+
}
|
|
3701
|
+
});
|
|
2669
3702
|
}
|
|
2670
3703
|
export {
|
|
2671
3704
|
resolveAdminRoot
|