@ultimat3/cli 22.15.0 → 23.0.0

package/src/scaffold-fixture.ts

@@ -1,160 +0,0 @@
-// What the scaffold drift gate compiles: every documented `x new` invocation, with every `x g`
-// generator run on top of the one that carries an app. Separate from the compiler harness next to
-// it, because "which scaffolds exist" is a fact about the CLI's surface, not about running `tsc`.
-
-import type { GenerateOptions } from './cmd-generate';
-import { dedupe, generate } from './cmd-generate';
-import { planNewApp } from './cmd-new';
-import type { GeneratedFile } from './templates';
-
-/** The app the fixture scaffolds. Kebab, multi-word: single-word names hide casing bugs. */
-export const FIXTURE_APP = 'ledger-demo';
-
-/**
- * An `errors.ts` an author wrote: it declares what the slice throws, and not the generated name.
- * The generator's INPUT only — the sandbox's own `errors.ts` is the one the resource wrote — so it
- * carries no `X_*` code: a literal here would be one shipped source hands a reader, and the
- * registry rule would ask where it was registered.
- */
-export const HANDWRITTEN_ERRORS = `import { UltimateError } from '@ultimat3/core';
-
-export class LedgerClosedError extends UltimateError {}
-`;
-
-/**
- * A feature slice whose entity is NOT tenant-scoped — the shape `x g entity`'s own comment
- * describes for a single-tenant app, and never a shape the generator writes itself. The
- * generator's INPUT only, the same way `HANDWRITTEN_ERRORS` above is: `x g job`/`x g task` read
- * this from a real `entity.ts`, and a fixture that never exercised it compiled only the shape
- * that never failed.
- */
-export const HANDWRITTEN_ENTITY_NO_TENANT = `import { entity, text, uuid } from '@ultimat3/entity';
-
-export const shortLink = entity('short_links', {
-  columns: { id: uuid().primaryKey(), url: text({ max: 2000 }) },
-});
-
-export type ShortLink = typeof shortLink.$row;
-`;
-
-/** The paired `repo.ts`: no `byId`, no `listByOrg` — nothing this slice's job may call. */
-export const HANDWRITTEN_REPO_NO_TENANT = `import { db, sql } from '@ultimat3/db';
-import type { ShortLink } from './entity';
-
-export async function list(limit = 50): Promise<readonly ShortLink[]> {
-  return db().query<ShortLink>(sql\`select * from short_links order by url limit \${limit}\`);
-}
-`;
-
-/**
- * The `invoice` resource's own `entity.ts`, as `x g` would read it off disk after the resource
- * below ran — the generators writing INTO that slice are handed it, because a slice with no entity
- * now gets the neutral body and no invented table.
- */
-export const INVOICE_ENTITY = String(
-  generate({ kind: 'entity', name: 'invoice' }).find((file) => file.path.endsWith('/entity.ts'))
-    ?.contents,
-);
-
-/**
- * One realistic invocation of every generator, on top of `x new --example`. Names differ from
- * their feature on purpose: `x g query invoice --feature invoice` would collide with the entity
- * import, and a fixture that trips over its own naming stops testing the templates.
- *
- * `admin: true` on the resource is not decoration: `apps/web/app/<name>/admin/resource.ts` and its
- * test are templates no other invocation emits, and they cost nothing extra here because they land
- * in a sandbox that is compiled anyway.
- */
-export const FIXTURE_GENERATORS: readonly GenerateOptions[] = [
-  { kind: 'resource', name: 'invoice', admin: true },
-  { kind: 'entity', name: 'credit-note', feature: 'credit-note' },
-  { kind: 'policy', name: 'credit-note', feature: 'credit-note' },
-  { kind: 'action', name: 'send-invoice', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  { kind: 'mutator', name: 'rename-invoice', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  // The other shape both templates have: a slice whose `errors.ts` is the author's and declares
-  // no `InvoiceNotFoundError`. The resource's own `errors.ts` still lands in the sandbox (it does
-  // declare one), which is the point — this compiles the file `x g action` writes when it must
-  // not import that class, beside the one it writes when it may.
-  {
-    kind: 'action',
-    name: 'ping-invoice',
-    feature: 'invoice',
-    sliceErrors: HANDWRITTEN_ERRORS,
-    sliceEntity: INVOICE_ENTITY,
-  },
-  {
-    kind: 'mutator',
-    name: 'touch-invoice',
-    feature: 'invoice',
-    sliceErrors: HANDWRITTEN_ERRORS,
-    sliceEntity: INVOICE_ENTITY,
-  },
-  { kind: 'query', name: 'invoice-search', feature: 'invoice' },
-  { kind: 'query', name: 'invoice-feed', feature: 'invoice', live: true },
-  { kind: 'job', name: 'sweep-invoices', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  { kind: 'backfill', name: 'reindex-invoices', feature: 'invoice' },
-  { kind: 'task', name: 'nightly-sweep', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  // The other shape both templates have: a feature whose entity names no tenant column, so the
-  // job/task must not assume one — compiled here beside the tenant-scoped pair above, exactly as
-  // `ping-invoice`/`touch-invoice` compile the action's other shape beside `send-invoice`.
-  {
-    kind: 'job',
-    name: 'purge-orphans',
-    feature: 'short-link',
-    sliceEntity: HANDWRITTEN_ENTITY_NO_TENANT,
-    sliceRepo: HANDWRITTEN_REPO_NO_TENANT,
-  },
-  {
-    kind: 'task',
-    name: 'nightly-purge',
-    feature: 'short-link',
-    sliceEntity: HANDWRITTEN_ENTITY_NO_TENANT,
-    sliceRepo: HANDWRITTEN_REPO_NO_TENANT,
-  },
-  { kind: 'route', name: 'pricing', surface: 'site' },
-  { kind: 'route', name: 'billing', surface: 'app' },
-  // `--at`, pointed at the `site/` route above: an island's whole reason to exist is a 0kb page
-  // that needs one interactive control, so the fixture places it where that is true.
-  { kind: 'island', name: 'currency-picker', at: 'apps/web/site/pricing' },
-  // The one screen the admin derives from nothing — and the one generator that must NOT emit a
-  // `defineRoute`, so compiling it is how that stays true.
-  { kind: 'admin:page', name: 'reconcile', permission: 'ledger:reconcile' },
-  // The app's own convention. It is the only generated file that imports `@ultimat3/cli` for its
-  // types, so compiling it is what proves a scaffolded app can actually write one.
-  { kind: 'guard', name: 'migration-safety' },
-];
-
-/** The whole scaffolded surface: a new app, then every generator run inside it. */
-export function scaffoldFixture(): readonly GeneratedFile[] {
-  return dedupe([
-    ...planNewApp({ name: FIXTURE_APP, example: true }),
-    ...FIXTURE_GENERATORS.flatMap((options) => generate(options)),
-  ]);
-}
-
-export interface ScaffoldVariant {
-  /** Names the invocation in a failure, so a red gate says which `x new` broke. */
-  readonly name: string;
-  /** What this variant emits that no other one does — why it earns its own compile. */
-  readonly why: string;
-  readonly files: readonly GeneratedFile[];
-}
-
-/**
- * Every scaffold a user can ask for, each compiled on its own. One variant per *file set*, not per
- * flag: `--no-example` writes a different `packages/db` than `--example` does, and compiling only
- * the example app is what let `x new --no-example` ship a `schema.ts` importing a slice that
- * invocation never writes.
- */
-export const scaffoldVariants = (): readonly ScaffoldVariant[] => [
-  {
-    name: 'x new',
-    why: 'the example slice, plus one run of every generator on top of it',
-    files: scaffoldFixture(),
-  },
-  {
-    name: 'x new --no-example',
-    why: 'an empty app/: no entity, so schema, seed and the initial migration have nothing to name',
-    files: planNewApp({ name: FIXTURE_APP, example: false }),
-  },
-];

package/src/templates/island-fixture.ts

@@ -1,76 +0,0 @@
-// TEST-ONLY. An app root on disk holding emitted files, with the packages an island imports
-// resolvable BY SPECIFIER the way a real app resolves them — so a template that emits
-// `import { Button } from '@ultimat3/ui'` is proven by a build that actually resolves it, and not
-// by a string assertion that the import is present.
-
-// `node:` by necessity, and SYNC by necessity: `[Symbol.dispose]` cannot await, so the teardown
-// half has to be synchronous — and Bun ships neither a path API nor a `symlink`.
-import { mkdirSync, rmSync, symlinkSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import type { GeneratedFile } from './naming';
-
-/** `packages/cli/src/templates` → the repo root, four hops up. */
-const REPO_ROOT = join(import.meta.dir, '..', '..', '..', '..');
-
-/**
- * INSIDE the checkout, and measured rather than chosen: the identical fixture under `os.tmpdir()`
- * fails every `@ultimat3/*` and every relative import inside it with `Could not resolve`, because
- * `Bun.build`'s resolver is scoped to the project `bun test` was started in and an app root outside
- * it cannot reach its own `node_modules`. `.prerender-fixture` is the same shape for the same
- * reason. The leading dot keeps it out of every `tsc` wildcard include.
- */
-const FIXTURE_ROOT = join(REPO_ROOT, 'packages', 'cli', '.island-fixture');
-
-/** The package the fixture lives inside. Linking it would aim a symlink at its own ancestor. */
-const SELF = 'cli';
-
-export interface FixtureApp extends Disposable {
-  /** Absolute path of the app root — what `buildIslands` globs from. */
-  readonly path: string;
-}
-
-/**
- * Symlinks rather than a `bun install`: the emitted island must resolve THIS working copy of
- * `@ultimat3/ui`, and an install in a fixture directory would fetch the registry's last release
- * and quietly prove nothing about the change under test. Every workspace is linked, not a chosen
- * few — a template that grows an import should build, not fail on a list nobody updated.
- */
-function linkDependencies(root: string): void {
-  const scope = join(root, 'node_modules', '@ultimat3');
-  mkdirSync(scope, { recursive: true });
-  const packages = join(REPO_ROOT, 'packages');
-  for (const entry of new Bun.Glob('*/package.json').scanSync({ cwd: packages })) {
-    const name = entry.slice(0, entry.indexOf('/'));
-    if (name === SELF) continue;
-    symlinkSync(join(packages, name), join(scope, name), 'dir');
-  }
-  // Resolved, never spelled as a path: the installer's layout is its own business and a hardcoded
-  // `node_modules/solid-js` is a fixture that breaks on a linker change rather than on a real one.
-  symlinkSync(
-    dirname(Bun.resolveSync('solid-js/package.json', REPO_ROOT)),
-    join(root, 'node_modules', 'solid-js'),
-    'dir',
-  );
-}
-
-/**
- * `Disposable`, so the idiom is `using root = await fixtureAppRoot(label, files)`. `label` is the
- * caller's, and is what keeps two test FILES off one directory: the path is fixed rather than
- * random, because a random one cannot be named in `.gitignore` and a crashed run leaves it behind.
- */
-export async function fixtureAppRoot(
-  label: string,
-  files: readonly GeneratedFile[],
-): Promise<FixtureApp> {
-  const path = join(FIXTURE_ROOT, label);
-  rmSync(path, { recursive: true, force: true });
-  mkdirSync(path, { recursive: true });
-  linkDependencies(path);
-  for (const file of files) await Bun.write(join(path, file.path), String(file.contents));
-  return {
-    path,
-    [Symbol.dispose]: (): void => {
-      rmSync(path, { recursive: true, force: true });
-    },
-  };
-}