mkdirp 0.5.6: verify recursive directory creation with mkdirp

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify recursive directory creation with mkdirp
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/mkdirp@0.5.6
Demonstrate these symbols/APIs:
  - mkdirp
  - mkdirp.sync

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:5c5cc84fa322595baf1930ecfb8830ff6684badae95148c22168cf1074c6298e","contract":["mkdirp asynchronously creates nested directories recursively and calls callback with made path","mkdirp succeeds and returns made null when target directory already exists","mkdirp.sync synchronously creates nested directories recursively and returns made path","mkdirp.sync succeeds and returns made null when target directory already exists"],"goal":"verify recursive directory creation with mkdirp","kind":"HOW","packages":["pkg:npm/mkdirp@0.5.6"],"schemaVersion":1,"symbols":["mkdirp","mkdirp.sync"]},"contractCommand":["node","test/contract.cjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/mkdirp@0.5.6"],"schemaVersion":1,"subject":"pkg:npm/mkdirp@0.5.6","symbols":["mkdirp","mkdirp.sync"],"verifierAdapter":"node-typescript@1"}

'use strict';

const mkdirp = require('mkdirp');

function makeDir(dirPath, opts, cb) {
  if (typeof opts === 'function') {
    cb = opts;
    opts = {};
  }
  return mkdirp(dirPath, opts, cb);
}

function makeDirSync(dirPath, opts) {
  return mkdirp.sync(dirPath, opts);
}

module.exports = {
  makeDir,
  makeDirSync,
  mkdirp
};

{
  "name": "sample-mkdirp",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-mkdirp",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "mkdirp": "0.5.6"
      }
    },
    "node_modules/minimist": {
      "version": "1.2.8",
      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/mkdirp": {
      "version": "0.5.6",
      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
      "license": "MIT",
      "dependencies": {
        "minimist": "^1.2.6"
      },
      "bin": {
        "mkdirp": "bin/cmd.js"
      }
    }
  }
}

{
  "name": "sample-mkdirp",
  "version": "1.0.0",
  "private": true,
  "description": "verify recursive directory creation with mkdirp in pkg:npm/mkdirp@0.5.6",
  "main": "index.js",
  "scripts": {
    "test": "node test/contract.cjs"
  },
  "dependencies": {
    "mkdirp": "0.5.6"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify recursive directory creation with mkdirp",
  "kind": "HOW",
  "packages": [
    "pkg:npm/mkdirp@0.5.6"
  ],
  "symbols": [
    "mkdirp",
    "mkdirp.sync"
  ]
}

'use strict';

const assert = require('assert');
const fs = require('fs');
const path = require('path');
const os = require('os');
const mkdirp = require('mkdirp');
const { makeDir, makeDirSync } = require('../index.js');

async function testAsync() {
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mkdirp-async-test-'));
  try {
    const targetDir = path.join(tmpDir, 'deep', 'nested', 'directory');
    
    // 1. Asynchronously create nested directories
    await new Promise((resolve, reject) => {
      mkdirp(targetDir, (err, made) => {
        if (err) return reject(err);
        try {
          assert.strictEqual(fs.existsSync(targetDir), true, 'target directory must exist');
          assert.strictEqual(typeof made, 'string', 'made must be a string path when created');
          resolve();
        } catch (assertionErr) {
          reject(assertionErr);
        }
      });
    });

    // 2. Asynchronously call mkdirp on an already existing directory (made must be null)
    await new Promise((resolve, reject) => {
      mkdirp(targetDir, (err, made) => {
        if (err) return reject(err);
        try {
          assert.strictEqual(fs.existsSync(targetDir), true, 'target directory must still exist');
          assert.strictEqual(made, null, 'made must be null when directory already exists');
          resolve();
        } catch (assertionErr) {
          reject(assertionErr);
        }
      });
    });

    // 3. Test helper makeDir
    const helperTarget = path.join(tmpDir, 'helper', 'nested', 'dir');
    await new Promise((resolve, reject) => {
      makeDir(helperTarget, (err, made) => {
        if (err) return reject(err);
        try {
          assert.strictEqual(fs.existsSync(helperTarget), true, 'helper directory must exist');
          assert.strictEqual(typeof made, 'string', 'made must be a string');
          resolve();
        } catch (assertionErr) {
          reject(assertionErr);
        }
      });
    });
  } finally {
    try {
      if (fs.existsSync(tmpDir)) {
        fs.rmSync(tmpDir, { recursive: true, force: true });
      }
    } catch (_) {}
  }
}

function testSync() {
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mkdirp-sync-test-'));
  try {
    const targetDir = path.join(tmpDir, 'sync', 'nested', 'folder');

    // 1. Synchronously create nested directories
    const madeSync = mkdirp.sync(targetDir);
    assert.strictEqual(fs.existsSync(targetDir), true, 'target directory must exist after mkdirp.sync');
    assert.strictEqual(typeof madeSync, 'string', 'madeSync must be a string path');

    // 2. Synchronously call mkdirp.sync on existing directory
    const existingMadeSync = mkdirp.sync(targetDir);
    assert.strictEqual(fs.existsSync(targetDir), true, 'target directory must exist');
    assert.strictEqual(existingMadeSync, null, 'made must be null for existing directory in mkdirp.sync');

    // 3. Test helper makeDirSync
    const helperTarget = path.join(tmpDir, 'helper-sync', 'deep', 'dir');
    const helperMade = makeDirSync(helperTarget);
    assert.strictEqual(fs.existsSync(helperTarget), true, 'helper sync directory must exist');
    assert.strictEqual(typeof helperMade, 'string', 'helperMade must be a string');
  } finally {
    try {
      if (fs.existsSync(tmpDir)) {
        fs.rmSync(tmpDir, { recursive: true, force: true });
      }
    } catch (_) {}
  }
}

async function run() {
  await testAsync();
  testSync();
  console.log('Contract tests passed successfully.');
}

run().catch((err) => {
  console.error('Contract test failed:', err);
  process.exit(1);
});