@saastemly/voidcommerce 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * voidcommerce — the library half of `vc`.
+ *
+ * The CLI is `bin/vc`. This is what a generator, a test, or Void itself one
+ * day, imports: the catalogue of choices, the manifest they are recorded in,
+ * and the generators that turn a manifest into files.
+ */
+export * from "./catalog";
+export * from "./manifest";
+export { generate, type GenerateResult } from "./generate/index";
+export { renderAuthTs } from "./generate/auth";
+export { allEnvKeys, envSummary, renderEnvExample, renderEnvLocal, renderEnvProduction, renderEnvTs, } from "./generate/env";
+export { renderRequirementsTs } from "./generate/requirements";
+export { renderDomainTs } from "./generate/support";
+export * from "./generate/strict";
+export { findProject, type Project } from "./project";
+export { parseJsonc, upsertJsonc } from "./deploy/jsonc";
+export { parseWhoAmI, findWrangler } from "./deploy/wrangler";
+export { preflight, printPreflight, productionEnv, routeProblem } from "./deploy/preflight";
+export { deployCloudflare } from "./deploy/cloudflare";
+export { FRONTEND_BRANCH, renderFrontendApiTs, renderFrontendEnvProduction, renderFrontendWorkflow, renderStorefrontPage, } from "./generate/frontend";
+export { distCommand, DIST_BRANCH, DIST_DIR } from "./dist";
+export { renderDistWorkflow, renderDeployReadme } from "./generate/ci";
+export { importCommand } from "./import";

package/dist/index.js

@@ -0,0 +1,190 @@
+import {
+  BRANDING_README,
+  CLIENT_ONLY,
+  DATA_README,
+  DIST_BRANCH,
+  DIST_DIR,
+  FRONTEND_BRANCH,
+  INDEX_PAGE,
+  MIGRATIONS_README,
+  STRICT_APP,
+  VOID_VERSION,
+  allEnvKeys,
+  deployCloudflare,
+  distCommand,
+  envSummary,
+  findProject,
+  findWrangler,
+  finishStrict,
+  generate,
+  importCommand,
+  parseJsonc,
+  parseWhoAmI,
+  preflight,
+  printPreflight,
+  productionEnv,
+  renderAppCss,
+  renderAuthClient,
+  renderAuthTs,
+  renderContentTs,
+  renderCron,
+  renderDashboardPage,
+  renderDbSchema,
+  renderDbSeed,
+  renderDeployReadme,
+  renderDistWorkflow,
+  renderDomainTs,
+  renderEnvExample,
+  renderEnvLocal,
+  renderEnvProduction,
+  renderEnvTs,
+  renderFrontendApiTs,
+  renderFrontendEnvProduction,
+  renderFrontendWorkflow,
+  renderIndexServer,
+  renderLayoutTsx,
+  renderLiveRoute,
+  renderLiveStream,
+  renderQueue,
+  renderRequirementsTs,
+  renderSignInPage,
+  renderStorefrontPage,
+  renderStrictAppPackageJson,
+  renderStrictTsconfig,
+  renderViteConfig,
+  renderVoidJson,
+  renderVoidPatch,
+  routeProblem,
+  strictDependencies,
+  upsertJsonc
+} from "./index-wzy1xtr1.js";
+import {
+  LAYOUTS,
+  MANIFEST_FILE,
+  OWN_PACKAGES,
+  chosenIn,
+  envKeysOf,
+  has,
+  hasFrontend,
+  isApex,
+  isSingleApp,
+  packagesOf,
+  readManifest,
+  specifier,
+  validate,
+  withRequired,
+  workerHosts,
+  writeManifest,
+  zone,
+  zoneOf
+} from "./index-ssv3a6wc.js";
+import {
+  AUTH_PLUGINS,
+  CARRIERS,
+  CHOICES,
+  COMMERCE_CATALOG,
+  COMMERCE_OPERATIONS,
+  COMMERCE_SALES,
+  CONTENT,
+  DNS,
+  EMAIL,
+  ERP,
+  GROUPS,
+  PAYMENT,
+  SIGN_IN,
+  TAX,
+  UI
+} from "./index-s7sq41qs.js";
+export {
+  zoneOf,
+  zone,
+  writeManifest,
+  workerHosts,
+  withRequired,
+  validate,
+  upsertJsonc,
+  strictDependencies,
+  specifier,
+  routeProblem,
+  renderVoidPatch,
+  renderVoidJson,
+  renderViteConfig,
+  renderStrictTsconfig,
+  renderStrictAppPackageJson,
+  renderStorefrontPage,
+  renderSignInPage,
+  renderRequirementsTs,
+  renderQueue,
+  renderLiveStream,
+  renderLiveRoute,
+  renderLayoutTsx,
+  renderIndexServer,
+  renderFrontendWorkflow,
+  renderFrontendEnvProduction,
+  renderFrontendApiTs,
+  renderEnvTs,
+  renderEnvProduction,
+  renderEnvLocal,
+  renderEnvExample,
+  renderDomainTs,
+  renderDistWorkflow,
+  renderDeployReadme,
+  renderDbSeed,
+  renderDbSchema,
+  renderDashboardPage,
+  renderCron,
+  renderContentTs,
+  renderAuthTs,
+  renderAuthClient,
+  renderAppCss,
+  readManifest,
+  productionEnv,
+  printPreflight,
+  preflight,
+  parseWhoAmI,
+  parseJsonc,
+  packagesOf,
+  isSingleApp,
+  isApex,
+  importCommand,
+  hasFrontend,
+  has,
+  generate,
+  finishStrict,
+  findWrangler,
+  findProject,
+  envSummary,
+  envKeysOf,
+  distCommand,
+  deployCloudflare,
+  chosenIn,
+  allEnvKeys,
+  VOID_VERSION,
+  UI,
+  TAX,
+  STRICT_APP,
+  SIGN_IN,
+  PAYMENT,
+  OWN_PACKAGES,
+  MIGRATIONS_README,
+  MANIFEST_FILE,
+  LAYOUTS,
+  INDEX_PAGE,
+  GROUPS,
+  FRONTEND_BRANCH,
+  ERP,
+  EMAIL,
+  DNS,
+  DIST_DIR,
+  DIST_BRANCH,
+  DATA_README,
+  CONTENT,
+  COMMERCE_SALES,
+  COMMERCE_OPERATIONS,
+  COMMERCE_CATALOG,
+  CLIENT_ONLY,
+  CHOICES,
+  CARRIERS,
+  BRANDING_README,
+  AUTH_PLUGINS
+};

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function init(args: string[]): Promise<number>;

package/dist/manifest.d.ts

@@ -0,0 +1,131 @@
+/**
+ * `voidcommerce.json` — what this shop is made of.
+ *
+ * ── Why a manifest and not just generated files ─────────────────────────
+ *
+ * A wizard that writes `auth.ts` once and forgets what it asked is a
+ * scaffolder: useful on day one, useless on day thirty when you want to add
+ * subscriptions and cannot remember which of the forty checkboxes you ticked.
+ *
+ * The manifest is the answers. Every generated file derives from it, so
+ * `vc init` on an existing project means "edit the answers and regenerate",
+ * and `vc gen` can read it to know what the shop already has. It is the
+ * Rails `config/` — the thing that makes the rest reproducible.
+ */
+export declare const MANIFEST_FILE = "voidcommerce.json";
+/**
+ * How the shop is laid out — on disk and on the internet.
+ *
+ *   app       One Void app: the API and the generated storefront and panel,
+ *             on Cloudflare Workers at <domain> and www.<domain>.
+ *   monorepo  api/       a Void app on Workers at api.<domain>, with the panel
+ *             frontend/  a static Void site on GitHub Pages at <domain>
+ *
+ *   strict    EXPERIMENTAL. A monorepo turned inside out. The REPOSITORY
+ *             ROOT is the storefront — its package.json, its pages, yours to
+ *             edit — and the worker is generated underneath it at .vc/app
+ *             from the manifest, gitignored, never hand-edited. Hosted the
+ *             way a monorepo is: the worker on api.<domain>, the storefront
+ *             on <domain>.
+ *
+ * The first question, because it decides where `void init` runs and what
+ * the domain means. It cannot change after init: moving files is not a
+ * regeneration.
+ */
+export type Layout = "app" | "monorepo" | "strict";
+export declare const LAYOUTS: Array<{
+    id: Layout;
+    label: string;
+    hint: string;
+}>;
+/**
+ * One worker that IS the site, with no storefront anywhere else.
+ *
+ * Only `app`. A monorepo has `frontend/`; strict has the storefront at the
+ * ROOT — what a person edits there is the shop front, and the worker is
+ * generated underneath it. Both put the worker on `api.<domain>` and the
+ * storefront on the domain itself.
+ */
+export declare const isSingleApp: (layout: Layout) => boolean;
+/** Does this layout carry a storefront of its own, and so a second origin to trust? */
+export declare const hasFrontend: (layout: Layout) => boolean;
+/** The zone a hostname most likely belongs to: the registrable domain. */
+export declare function zoneOf(domain: string): string;
+/** The zone this shop's records go in. */
+export declare function zone(manifest: Manifest): string;
+/** Is the shop at the zone's apex? Only then is there a `www` to answer on. */
+export declare function isApex(manifest: Manifest): boolean;
+/** Every hostname the worker answers on — the wrangler routes, in order. */
+export declare function workerHosts(manifest: Manifest): string[];
+export interface Manifest {
+    /** Schema version, for the day the shape changes. */
+    version: 1;
+    layout: Layout;
+    shop: {
+        name: string;
+        /** `deki.dk`, or `tshirt.saastemly.com` — the shop's public hostname; everything derives from it. */
+        domain: string;
+        /**
+         * The DNS zone that CONTAINS the domain: `deki.dk` for an apex,
+         * `saastemly.com` for `tshirt.saastemly.com`. Records are written here,
+         * and a Worker custom domain needs this zone on Cloudflare. Absent
+         * means the domain is its own zone.
+         */
+        zone?: string | undefined;
+        /** `DK` — drives the declared VAT rate and the default region. */
+        country: string;
+        /** `dkk` */
+        currency: string;
+        /** `da` — copy in emails and launch content. */
+        locale: string;
+        /**
+         * Is the shop registered for VAT (or its local equivalent)?
+         *
+         * Not a preference. A business below the registration threshold must
+         * NOT add tax to a price, and one above it must. Getting this wrong is
+         * unlawful in both directions, and it is invisible in a generated
+         * `auth.ts` unless something asks — so this asks, and there is no
+         * default that is safe to assume.
+         */
+        taxRegistered?: boolean | undefined;
+        /** `saastemly.github.io` — the monorepo's frontend lives on GitHub Pages; the www record points here. */
+        pagesHost?: string | undefined;
+    };
+    /** Chosen ids from each group, keyed by group id. */
+    chosen: Record<string, string[]>;
+    /**
+     * Where the betterCommerce packages come from, when not from npm.
+     * `vc init --link ../` writes `file:../better-commerce` and friends, so a
+     * checkout of the whole suite installs. Absent means the registry.
+     */
+    link?: string | undefined;
+    /**
+     * What `vc deploy --cloudflare --provision` created. Recorded here so a
+     * regenerated wrangler.jsonc (strict) carries the real ids.
+     */
+    cloudflare?: {
+        accountId?: string;
+        d1?: {
+            name: string;
+            id: string;
+        };
+    };
+}
+/** Everything a group's `required` choices and the layout imply, whatever was ticked. */
+export declare function withRequired(chosen: Record<string, string[]>, layout?: Layout): Record<string, string[]>;
+/** Is a choice in the manifest, in any group? */
+export declare function has(manifest: Manifest, id: string): boolean;
+/** The chosen ids of one group — for ids like `none` that several groups use. */
+export declare function chosenIn(manifest: Manifest, groupId: string): string[];
+/** Every env key the chosen set needs, deduplicated, in group order. */
+export declare function envKeysOf(manifest: Manifest): import("./catalog").EnvKey[];
+/** The packages this suite publishes, which a checkout can supply instead of npm. */
+export declare const OWN_PACKAGES: string[];
+/** What a dependency on `name` should say: a link into the checkout, or a version. */
+export declare function specifier(manifest: Manifest, name: string, version?: string): string;
+/** Every npm package the chosen set needs — for the app, or the monorepo's api/. */
+export declare function packagesOf(manifest: Manifest): string[];
+export declare function readManifest(root: string): Promise<Manifest | null>;
+export declare function writeManifest(root: string, manifest: Manifest): Promise<void>;
+/** Refuse a manifest that contradicts the catalogue's rules or its own layout. */
+export declare function validate(manifest: Manifest): string[];

package/dist/manifest.js

@@ -0,0 +1,41 @@
+import {
+  LAYOUTS,
+  MANIFEST_FILE,
+  OWN_PACKAGES,
+  chosenIn,
+  envKeysOf,
+  has,
+  hasFrontend,
+  isApex,
+  isSingleApp,
+  packagesOf,
+  readManifest,
+  specifier,
+  validate,
+  withRequired,
+  workerHosts,
+  writeManifest,
+  zone,
+  zoneOf
+} from "./index-ssv3a6wc.js";
+import"./index-s7sq41qs.js";
+export {
+  zoneOf,
+  zone,
+  writeManifest,
+  workerHosts,
+  withRequired,
+  validate,
+  specifier,
+  readManifest,
+  packagesOf,
+  isSingleApp,
+  isApex,
+  hasFrontend,
+  has,
+  envKeysOf,
+  chosenIn,
+  OWN_PACKAGES,
+  MANIFEST_FILE,
+  LAYOUTS
+};

package/dist/project.d.ts

@@ -0,0 +1,20 @@
+import { type Manifest } from "./manifest";
+/**
+ * The project vc is standing in, if any.
+ *
+ * The manifest names the root. Where void's commands run follows the layout:
+ * the root itself for one app; api/ for a monorepo — from the root or from
+ * inside api/; the artifact under .vc/app for strict, generated first if it
+ * is not there.
+ */
+export interface Project {
+    root: string;
+    manifest: Manifest;
+    /** Where void's commands run. */
+    appDir: string;
+    /** Strict only: the artifact has not been generated yet. */
+    needsGenerate: boolean;
+}
+export declare function findProject(cwd?: string): Promise<Project | null>;
+/** A strict artifact that is not there yet is generated before anything runs in it. */
+export declare function ensureGenerated(project: Project): Promise<number>;

package/dist/regenerate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `vc generate` — the files from the manifest, without the form.
+ *
+ * In one-app and monorepo layouts it rewrites the regenerated files and
+ * keeps the owned ones. In strict it is the whole app: every file under
+ * .vc/app, then void's own artifacts and the migrations.
+ */
+export declare function generateCommand(): Promise<number>;
+export declare function generateHelp(): Promise<number>;

package/dist/scripts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `vc dev`, `vc build`, `vc preview` — the app's own scripts, where the app is.
+ *
+ * void has no `dev` command: `void init` writes `dev`, `build` and `preview`
+ * into the app's package.json (`vp dev`, or `vite dev`), and that is what
+ * runs. vc adds nothing to them but the WHERE — a monorepo's api/ from the
+ * root, a strict artifact under .vc/app, generated first if it is not there.
+ * Outside a project they go to void, which says what it thinks of them.
+ */
+export type AppScript = "dev" | "build" | "preview";
+export declare function appScript(name: AppScript): (args: string[]) => Promise<number>;
+export declare function appScriptHelp(name: AppScript): () => Promise<number>;

package/dist/void.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The `void` binary, and the two ways vc uses it.
+ *
+ * `runVoid` hands the terminal over — for everything vc passes through, and
+ * for `void init` when vc extends it. `captureVoid` reads what void would
+ * have printed, so vc can merge its own lines into void's help rather than
+ * replace it.
+ *
+ * Void is the app's dependency, not vc's, so the nearest node_modules wins,
+ * then PATH, then `bunx void` — the way Void's own docs say to invoke it.
+ */
+export interface VoidBin {
+    cmd: string;
+    prefix: string[];
+}
+export declare function findVoid(from?: string): VoidBin | null;
+export declare const VOID_MISSING = "`void` is not installed here. `bun add -d void` \u2014 Void recommends a local install \u2014 then try again.";
+/** Hand the terminal to void. Resolves with the exit code void would have had. */
+export declare function runVoid(args: string[], cwd?: string): Promise<number>;
+/** Hand the terminal to any command, forwarding signals, resolving with its exit code. */
+export declare function runInherit(cmd: string, args: string[], cwd: string): Promise<number>;
+/** What void prints for `args`, or null when void is not here. Stdout then stderr, as void ordered them. */
+export declare function captureVoid(args: string[], cwd?: string): Promise<{
+    code: number;
+    out: string;
+} | null>;
+/** A directory Void already knows: its Vite config imports void, or it carries a void.json. */
+export declare function isVoidApp(dir: string): boolean;
+/** The Void apps directly under `dir` — for when `void init` chose to make a subfolder. */
+export declare function voidAppsIn(dir: string): string[];

package/dist/wizard.d.ts

@@ -0,0 +1,7 @@
+import { type Layout, type Manifest } from "./manifest";
+/** The first question. */
+export declare function askLayout(): Promise<Layout>;
+/** The rest of the form, once the layout is known and the Void app(s) exist. */
+export declare function runWizard(existing: Manifest | null, layout: Layout): Promise<Manifest>;
+/** A closing summary the person can read before anything is written. */
+export declare function summarise(manifest: Manifest): string;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@saastemly/voidcommerce",
+  "version": "0.1.0",
+  "description": "Void, with a shop in it. `vc init` walks you through Better Auth, betterCommerce and every plugin; everything else passes through to `void`.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "vc": "./bin/vc",
+    "@saastemly/voidcommerce": "./bin/vc"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./catalog": {
+      "types": "./dist/catalog.d.ts",
+      "default": "./dist/catalog.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "default": "./dist/manifest.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build ./src/index.ts ./src/catalog.ts ./src/manifest.ts ./src/cli.ts --root ./src --outdir dist --target node --format esm --splitting --external @clack/prompts --external picocolors && tsc -p tsconfig.build.json",
+    "test": "bun test --parallel --no-isolate",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/saastemly/voidcommerce.git"
+  }
+}