Template Method

1type ImportSteps = {
2  fetch: () => Promise<EncryptedFile>
3  parse: (rows: RawRow[]) => Result<Row[], ParseError>
4  dedupe?: (rows: Row[]) => Row[]        // partner five only; default: identity
5}
6 
7export async function runImport(partner: PartnerId, steps: ImportSteps) {
8  const file = await withRetry(steps.fetch)          // shared: retry policy
9  const raw = await decryptAndSplit(file)            // shared
10  const parsed = steps.parse(raw)                    // varies
11  if (!parsed.ok) return audit.failed(partner, parsed.error)   // shared
12  const rows = (steps.dedupe ?? ((r) => r))(parsed.value)      // optional step
13  await upsertAll(rows)                              // shared
14  await archive(file, partner)                       // shared
15  return audit.succeeded(partner, rows.length)       // shared
16}
17 
18// partners/acme.ts
19export const acme = { fetch: sftpFetch(acmeConfig), parse: parseAcmeCsv }

Adding partner five is one object literal. The optional dedupe is how the extra step is absorbed without a second level of hierarchy — a default that does nothing, stated explicitly.

abstract class ImportJob {
  protected abstract fetch(): Promise<EncryptedFile>
  protected abstract parse(rows: RawRow[]): Result<Row[], ParseError>
  protected beforeUpsert(rows: Row[]) { return rows }   // hook #1
  protected shouldArchive() { return true }             // hook #2

  async run() { /* the seven steps, calling the above */ }
}

class AcmeImport extends ImportJob { /* two overrides */ }
class DedupeImport extends AcmeImport { /* second level */ }
// run() is not final: a subclass can replace the sequence entirely.

runImport('acme', { fetch: sftpFetch(cfg), parse: parseAcmeCsv })
runImport('globex', { fetch: httpFetch(cfg), parse: parseXml, dedupe })

// Extension points are exactly the fields of ImportSteps.
// There is no second level, no protected surface, and the
// sequence cannot be overridden because it is not a method.

Both put the five shared steps in one place, which is the change that actually pays. The difference is what else they permit: the base class exposes every protected member as an extension point, allows run() itself to be replaced — losing the invariant the design existed to protect — and invites a second level of subclass the moment one partner differs slightly. The parameter version cannot be extended except through the fields you declared, and a reader of the call site sees the entire variation on one line (Exposing Too Much).