Lab

Factory

FACTORY-101 Easy · Build ~15 min

The output root moved and two callers did not

The CLI, the watch task and the release task each write out the whole build configuration. The team has just made the default output directory a setting (the output root) so it can move builds from dist to out. The callers were written before the setting existed.

When the setting moves, every caller that spelled out its directory keeps building into the old one, without any error. The same happens with the next default anyone changes.

Reproduce

Set settings.outputRoot = "out", then call releaseConfig(): it should build into out/library. Today it still builds into dist/library, and so does watchConfig().

Acceptance criteria

One factory fills every field from the preset (library: esm, app: iife), the mode (production minifies), the output root and the caller’s overrides.
A caller’s explicit choice always wins over a default: its own directory, and minify false in production.
An unknown preset or mode is rejected.
The three callers ask the factory, so when the output root moves, the callers that did not choose a directory follow it.

Check work runs these cases against your code once you sign in.

Not run:The release task follows the moved output root
settings.outputRoot = "out"; releaseConfig()
Not run:The watch task follows it too
settings.outputRoot = "out"; watchConfig()
Not run:The CLI keeps the directory it chose
settings.outputRoot = "out"; cliConfig()
Not run:The release task still gets readable production output
releaseConfig()
Not run:An explicit false is kept in production
resolveBuildConfig("library", { mode: "production", minify: false })
Not run:Production without a choice minifies
resolveBuildConfig("library", { mode: "production" })
Not run:Development without a choice does not
resolveBuildConfig("app", {})
Not run:An explicit true is kept in development
settings.outputRoot = "out"; resolveBuildConfig("app", { minify: true })
Not run:A caller’s own directory is kept when the root moves
settings.outputRoot = "out"; resolveBuildConfig("app", { outDir: "build" })
Not run:An unknown preset is rejected
resolveBuildConfig("desktop", {})
Not run:An unknown mode is rejected
resolveBuildConfig("app", { mode: "staging" })

Notes

Cases print a configuration as mode, target, format, minify and output directory, or rejected.
The checker sets the output root before each case. Keep the factory’s name and signature and the three callers’ names; the checker calls them.
The release task asks for minify false on purpose: a readable production bundle is how the team debugs production bugs.

Hints

Reference answerTry the cases first

type Overrides = { mode?: string; minify?: boolean; outDir?: string };
type BuildConfig = Readonly<{
  mode: string;
  target: string;
  format: string;
  minify: boolean;
  outDir: string;
}>;

// The team's settings: where builds go unless a caller says otherwise.
// The checker changes outputRoot between cases.
const settings = { outputRoot: 'dist' };

// The factory: the preset's rules, the defaults and the caller's overrides, in one place.
function resolveBuildConfig(preset: string, overrides: Overrides = {}): BuildConfig {
  if (preset !== 'library' && preset !== 'app') throw new Error(`unknown preset: ${preset}`);
  const mode = overrides.mode ?? 'development';
  if (mode !== 'development' && mode !== 'production') throw new Error(`unknown mode: ${mode}`);
  return Object.freeze({
    mode,
    target: 'es2022',
    format: preset === 'library' ? 'esm' : 'iife',
    minify: overrides.minify ?? mode === 'production',
    outDir: overrides.outDir ?? `${settings.outputRoot}/${preset}`,
  });
}

// Three callers, each saying only what it knows.
function cliConfig(): BuildConfig {
  return resolveBuildConfig('app', { outDir: 'build' });
}
function watchConfig(): BuildConfig {
  return resolveBuildConfig('library');
}
// Release builds stay readable (minify: false), so a production bug can be debugged from the bundle.
function releaseConfig(): BuildConfig {
  return resolveBuildConfig('library', { mode: 'production', minify: false });
}

The factory owns everything the callers used to repeat: the format each preset implies, the target, minify following the mode, and the output directory following the team’s setting at the moment of the call. Each caller now says only what it knows: the CLI its directory, the release task its mode and its deliberate false. Asking “did the caller choose?” per field (?? in TypeScript, a nil pointer in Go, None in Rust) is what lets a chosen directory and a chosen false survive their defaults. The checker moved the output root to prove the callers use the factory: a caller that still writes its configuration out cannot follow a default it does not ask for.

Sign in to run your code

Read the brief and the starter here. With a free account you can edit it, run the sample, step through it and check your work, and your progress is kept.

type Overrides = { mode?: string; minify?: boolean; outDir?: string };
type BuildConfig = Readonly<{
  mode: string;
  target: string;
  format: string;
  minify: boolean;
  outDir: string;
}>;

// The team's settings: where builds go unless a caller says otherwise.
// The checker changes outputRoot between cases.
const settings = { outputRoot: 'dist' };

// The factory the callers should share. Not written yet.
function resolveBuildConfig(preset: string, overrides: Overrides = {}): BuildConfig {
  throw new Error('not written yet');
}

// Three callers, each writing the whole configuration.
function cliConfig(): BuildConfig {
  return { mode: 'development', target: 'es2022', format: 'iife', minify: false, outDir: 'build' };
}
function watchConfig(): BuildConfig {
  return { mode: 'development', target: 'es2022', format: 'esm', minify: false, outDir: 'dist/library' };
}
// Release builds stay readable (minify: false), so a production bug can be debugged from the bundle.
function releaseConfig(): BuildConfig {
  return { mode: 'production', target: 'es2022', format: 'esm', minify: false, outDir: 'dist/library' };
}