@neurodevs/meta-node 0.0.1 → 0.1.0

package/build/scripts/runAutomodule.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NodeAutomodule_1 = __importDefault(require("../modules/NodeAutomodule"));
+async function main() {
+    console.log('\nRunning automodule...');
+    const instance = NodeAutomodule_1.default.Create({
+        testSaveDir: '/Users/ericthecurious/dev/meta-node/src/__tests__/modules',
+        moduleSaveDir: '/Users/ericthecurious/dev/meta-node/src/modules',
+        interfaceName: 'Autocomponent',
+        implName: 'ReactAutocomponent',
+    });
+    await instance.run();
+    console.log('Finished running automodule!\n');
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=runAutomodule.js.map

package/build/scripts/runAutomodule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runAutomodule.js","sourceRoot":"","sources":["../../src/scripts/runAutomodule.ts"],"names":[],"mappings":";;;;;AAAA,+EAAsD;AAEtD,KAAK,UAAU,IAAI;IACf,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAA;IAEtC,MAAM,QAAQ,GAAG,wBAAc,CAAC,MAAM,CAAC;QACnC,WAAW,EACP,2DAA2D;QAC/D,aAAa,EAAE,iDAAiD;QAChE,aAAa,EAAE,eAAe;QAC9B,QAAQ,EAAE,oBAAoB;KACjC,CAAC,CAAA;IAEF,MAAM,QAAQ,CAAC,GAAG,EAAE,CAAA;IAEpB,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAA;AACjD,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACjB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAClB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACnB,CAAC,CAAC,CAAA"}

package/build/scripts/runAutopackage.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const NpmAutopackage_1 = __importDefault(require("../modules/NpmAutopackage"));
-async function run() {
-    console.log('Running...');
+async function main() {
+    console.log('Running autopackage...');
     await NpmAutopackage_1.default.Create({
         name: 'node-xyz',
         description: 'XYZ, yo',
@@ -19,7 +19,7 @@ async function run() {
     console.log('Done!');
     process.exit(0);
 }
-run().catch((err) => {
+main().catch((err) => {
     console.error(err);
     process.exit(1);
 });

package/build/scripts/runAutopackage.js.map

@@ -1 +1 @@
-{"version":3,"file":"runAutopackage.js","sourceRoot":"","sources":["../../src/scripts/runAutopackage.ts"],"names":[],"mappings":";;;;;AAAA,iDAAwC;AACxC,+EAAsD;AAEtD,KAAK,UAAU,GAAG;IACd,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IAEzB,MAAM,wBAAc,CAAC,MAAM,CAAC;QACxB,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,SAAS;QACtB,YAAY,EAAE,WAAW;QACzB,YAAY,EAAE,WAAW;QACzB,UAAU,EAAE,2BAA2B;KAC1C,CAAC,CAAA;IAEF,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAA;IACnC,IAAA,wBAAQ,EAAC,QAAQ,CAAC,CAAA;IAClB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAEpB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACnB,CAAC;AAED,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IAChB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAClB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACnB,CAAC,CAAC,CAAA"}
+{"version":3,"file":"runAutopackage.js","sourceRoot":"","sources":["../../src/scripts/runAutopackage.ts"],"names":[],"mappings":";;;;;AAAA,iDAAwC;AACxC,+EAAsD;AAEtD,KAAK,UAAU,IAAI;IACf,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAA;IAErC,MAAM,wBAAc,CAAC,MAAM,CAAC;QACxB,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,SAAS;QACtB,YAAY,EAAE,WAAW;QACzB,YAAY,EAAE,WAAW;QACzB,UAAU,EAAE,2BAA2B;KAC1C,CAAC,CAAA;IAEF,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAA;IACnC,IAAA,wBAAQ,EAAC,QAAQ,CAAC,CAAA;IAClB,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAEpB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACnB,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACjB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAClB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AACnB,CAAC,CAAC,CAAA"}

package/build/testDoubles/Automodule/FakeAutomodule.d.ts

@@ -0,0 +1,8 @@
+import { Automodule, AutomoduleOptions } from '../../modules/NodeAutomodule';
+export default class FakeAutomodule implements Automodule {
+    static callsToConstructor: AutomoduleOptions[];
+    static numCallsToRun: number;
+    constructor(options: AutomoduleOptions);
+    run(): Promise<void>;
+    static resetTestDouble(): void;
+}

package/build/testDoubles/Automodule/FakeAutomodule.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FakeAutomodule {
+    constructor(options) {
+        FakeAutomodule.callsToConstructor.push(options);
+    }
+    async run() {
+        FakeAutomodule.numCallsToRun++;
+    }
+    static resetTestDouble() {
+        this.callsToConstructor = [];
+        this.numCallsToRun = 0;
+    }
+}
+FakeAutomodule.callsToConstructor = [];
+FakeAutomodule.numCallsToRun = 0;
+exports.default = FakeAutomodule;
+//# sourceMappingURL=FakeAutomodule.js.map

package/build/testDoubles/Automodule/FakeAutomodule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeAutomodule.js","sourceRoot":"","sources":["../../../src/testDoubles/Automodule/FakeAutomodule.ts"],"names":[],"mappings":";;AAEA,MAAqB,cAAc;IAI/B,YAAmB,OAA0B;QACzC,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACnD,CAAC;IAEM,KAAK,CAAC,GAAG;QACZ,cAAc,CAAC,aAAa,EAAE,CAAA;IAClC,CAAC;IAEM,MAAM,CAAC,eAAe;QACzB,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAA;QAC5B,IAAI,CAAC,aAAa,GAAG,CAAC,CAAA;IAC1B,CAAC;;AAda,iCAAkB,GAAwB,EAAE,CAAA;AAC5C,4BAAa,GAAG,CAAC,CAAA;kBAFd,cAAc"}

package/build/testDoubles/fs/fakePathExists.d.ts

@@ -0,0 +1,3 @@
+export declare let pathShouldExist: Record<string, boolean>;
+export declare function setPathShouldExist(path: string, shouldExist: boolean): void;
+export default function fakePathExists(path: string): Promise<boolean>;

package/build/testDoubles/fs/fakePathExists.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathShouldExist = void 0;
+exports.setPathShouldExist = setPathShouldExist;
+exports.default = fakePathExists;
+exports.pathShouldExist = {};
+function setPathShouldExist(path, shouldExist) {
+    exports.pathShouldExist[path] = shouldExist;
+}
+async function fakePathExists(path) {
+    return exports.pathShouldExist[path];
+}
+//# sourceMappingURL=fakePathExists.js.map

package/build/testDoubles/fs/fakePathExists.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakePathExists.js","sourceRoot":"","sources":["../../../src/testDoubles/fs/fakePathExists.ts"],"names":[],"mappings":";;;AAEA,gDAEC;AAED,iCAEC;AARU,QAAA,eAAe,GAA4B,EAAE,CAAA;AAExD,SAAgB,kBAAkB,CAAC,IAAY,EAAE,WAAoB;IACjE,uBAAe,CAAC,IAAI,CAAC,GAAG,WAAW,CAAA;AACvC,CAAC;AAEc,KAAK,UAAU,cAAc,CAAC,IAAY;IACrD,OAAO,uBAAe,CAAC,IAAI,CAAC,CAAA;AAChC,CAAC"}

package/build/testDoubles/fs/fakeWriteFile.d.ts

@@ -0,0 +1,6 @@
+export declare let callsToWriteFile: {
+    file: string;
+    data: string;
+}[];
+export declare function resetCallsToWriteFile(): void;
+export default function fakeWriteFile(file: string, data: string): Promise<void>;

package/build/testDoubles/fs/fakeWriteFile.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callsToWriteFile = void 0;
+exports.resetCallsToWriteFile = resetCallsToWriteFile;
+exports.default = fakeWriteFile;
+exports.callsToWriteFile = [];
+function resetCallsToWriteFile() {
+    exports.callsToWriteFile = [];
+}
+async function fakeWriteFile(file, data) {
+    exports.callsToWriteFile.push({ file, data });
+}
+//# sourceMappingURL=fakeWriteFile.js.map

package/build/testDoubles/fs/fakeWriteFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeWriteFile.js","sourceRoot":"","sources":["../../../src/testDoubles/fs/fakeWriteFile.ts"],"names":[],"mappings":";;;AAEA,sDAEC;AAED,gCAEC;AARU,QAAA,gBAAgB,GAAqC,EAAE,CAAA;AAElE,SAAgB,qBAAqB;IACjC,wBAAgB,GAAG,EAAE,CAAA;AACzB,CAAC;AAEc,KAAK,UAAU,aAAa,CAAC,IAAY,EAAE,IAAY;IAClE,wBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;AACzC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neurodevs/meta-node",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Meta-layer utilities for maintaining Node.js package ecosystems.",
   "repository": "https://github.com/neurodevs/meta-node.git",
   "main": "build/index.js",

package/src/__tests__/modules/NodeAutomodule.test.ts

@@ -0,0 +1,160 @@
+import { writeFile } from 'fs/promises'
+import AbstractSpruceTest, {
+    test,
+    assert,
+    generateId,
+} from '@sprucelabs/test-utils'
+import NodeAutomodule, { Automodule } from '../../modules/NodeAutomodule'
+import fakePathExists, {
+    setPathShouldExist,
+} from '../../testDoubles/fs/fakePathExists'
+import fakeWriteFile, {
+    callsToWriteFile,
+    resetCallsToWriteFile,
+} from '../../testDoubles/fs/fakeWriteFile'
+
+export default class NodeAutomoduleTest extends AbstractSpruceTest {
+    private static instance: Automodule
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.setFakePathExists()
+        this.setFakeWriteFile()
+
+        this.instance = this.NodeAutomodule()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    @test()
+    protected static async runThrowsIfTestSaveDirMissing() {
+        setPathShouldExist(this.testSaveDir, false)
+
+        const err = await assert.doesThrowAsync(async () => await this.run())
+
+        assert.isEqual(
+            err.message,
+            `testSaveDir does not exist: ${this.testSaveDir}!`,
+            'Did not receive the expected error!'
+        )
+    }
+
+    @test()
+    protected static async runThrowsIfModuleSaveDirMissing() {
+        setPathShouldExist(this.moduleSaveDir, false)
+
+        const err = await assert.doesThrowAsync(async () => await this.run())
+
+        assert.isEqual(
+            err.message,
+            `moduleSaveDir does not exist: ${this.moduleSaveDir}!`,
+            'Did not receive the expected error!'
+        )
+    }
+
+    @test()
+    protected static async createsTestFileAsExpected() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToWriteFile[0],
+            {
+                file: `${this.testSaveDir}/${this.implName}.test.ts`,
+                data: this.testFilePattern,
+            },
+            'Did not write expected test file!'
+        )
+    }
+
+    @test()
+    protected static async createsModuleFileAsExpected() {
+        await this.run()
+
+        assert.isEqualDeep(
+            callsToWriteFile[1],
+            {
+                file: `${this.moduleSaveDir}/${this.implName}.ts`,
+                data: this.moduleFilePattern,
+            },
+            'Did not write expected module file!'
+        )
+    }
+
+    private static async run() {
+        return await this.instance.run()
+    }
+
+    private static setFakePathExists() {
+        NodeAutomodule.pathExists = fakePathExists
+
+        setPathShouldExist(this.testSaveDir, true)
+        setPathShouldExist(this.moduleSaveDir, true)
+    }
+
+    private static setFakeWriteFile() {
+        NodeAutomodule.writeFile = fakeWriteFile as typeof writeFile
+        resetCallsToWriteFile()
+    }
+
+    private static readonly testSaveDir = generateId()
+    private static readonly moduleSaveDir = generateId()
+    private static readonly interfaceName = generateId()
+    private static readonly implName = generateId()
+
+    private static get testFilePattern() {
+        return `
+            import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
+            import ${this.implName}, { ${this.interfaceName} } from '../../modules/${this.implName}'
+
+            export default class ${this.implName}Test extends AbstractSpruceTest {
+                private static instance: ${this.interfaceName}
+                
+                protected static async beforeEach() {
+                    await super.beforeEach()
+                    
+                    this.instance = this.${this.implName}()
+                }
+                
+                @test()
+                protected static async createsInstance() {
+                    assert.isTruthy(this.instance, 'Failed to create instance!')
+                }
+                
+                private static ${this.implName}() {
+                    return ${this.implName}.Create()
+                }
+            }
+        `
+    }
+
+    private static get moduleFilePattern() {
+        return `
+            export default class ${this.implName} implements ${this.interfaceName} {
+                public static Class?: ${this.interfaceName}Constructor
+                
+                protected constructor() {}
+                
+                public static Create() {
+                    return new (this.Class ?? this)()
+                }
+            }
+
+            export interface ${this.interfaceName} {}
+
+            export type ${this.interfaceName}Constructor = new () => ${this.interfaceName}
+        `
+    }
+
+    private static NodeAutomodule() {
+        return NodeAutomodule.Create({
+            testSaveDir: this.testSaveDir,
+            moduleSaveDir: this.moduleSaveDir,
+            interfaceName: this.interfaceName,
+            implName: this.implName,
+        })
+    }
+}

package/src/__tests__/modules/PackageJsonUpdater.test.ts

@@ -0,0 +1,23 @@
+import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
+import PackageJsonUpdater, {
+    JsonUpdater,
+} from '../../modules/PackageJsonUpdater'
+
+export default class PackageJsonUpdaterTest extends AbstractSpruceTest {
+    private static instance: JsonUpdater
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.instance = this.PackageJsonUpdater()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    private static PackageJsonUpdater() {
+        return PackageJsonUpdater.Create()
+    }
+}

package/src/index.ts

@@ -1,8 +1,3 @@
-// Autopackage
-
-export { default as NpmAutopackage } from './modules/NpmAutopackage'
-export * from './modules/NpmAutopackage'
-
 // Autocloner
 
 export { default as GitAutocloner } from './modules/GitAutocloner'
@@ -10,3 +5,21 @@ export * from './modules/GitAutocloner'
 
 export { default as FakeAutocloner } from './testDoubles/Autocloner/FakeAutocloner'
 export * from './testDoubles/Autocloner/FakeAutocloner'
+
+// Automodule
+
+export { default as NodeAutomodule } from './modules/NodeAutomodule'
+export * from './modules/NodeAutomodule'
+
+export { default as FakeAutomodule } from './testDoubles/Automodule/FakeAutomodule'
+export * from './testDoubles/Automodule/FakeAutomodule'
+
+// Autopackage
+
+export { default as NpmAutopackage } from './modules/NpmAutopackage'
+export * from './modules/NpmAutopackage'
+
+// PackageJsonUpdater
+
+export { default as PackageJsonUpdater } from './modules/PackageJsonUpdater'
+export * from './modules/PackageJsonUpdater'

package/src/modules/GitAutocloner.ts

@@ -32,12 +32,16 @@ export default class GitAutocloner implements Autocloner {
 
     private throwIfDirPathDoesNotExist() {
         if (!this.dirPathExists) {
-            throw new Error(this.dirPathDoesNotExistMessage)
+            this.throwDirPathDoesNotExist()
         }
     }
 
-    private get dirPathDoesNotExistMessage() {
-        return `dirPath does not exist: ${this.dirPath}!`
+    private get dirPathExists() {
+        return this.existsSync(this.dirPath)
+    }
+
+    private throwDirPathDoesNotExist() {
+        throw new Error(`dirPath does not exist: ${this.dirPath}!`)
     }
 
     private changeDirectoryToDirPath() {
@@ -55,10 +59,20 @@ export default class GitAutocloner implements Autocloner {
         if (!this.currentRepoExists) {
             this.tryToCloneRepo()
         } else {
-            this.log.info(this.repoExistsMessage)
+            this.log.info(`Repo exists, skipping: ${this.currentRepoName}!`)
         }
     }
 
+    private get currentRepoExists() {
+        return this.existsSync(this.currentRepoName)
+    }
+
+    private get currentRepoName() {
+        return this.currentUrl.match(this.regexForRepoName)![1]
+    }
+
+    private readonly regexForRepoName = /\/([a-zA-Z0-9_.-]+)\.git/
+
     private tryToCloneRepo() {
         try {
             this.execSync(`git clone ${this.currentUrl}`)
@@ -76,22 +90,6 @@ export default class GitAutocloner implements Autocloner {
         return `Git clone failed for repo: ${this.currentUrl}!\n\n${this.currentError}\n\n`
     }
 
-    private get dirPathExists() {
-        return this.existsSync(this.dirPath)
-    }
-
-    private get currentRepoName() {
-        return this.currentUrl.match(this.regex)![1]
-    }
-
-    private get currentRepoExists() {
-        return this.existsSync(this.currentRepoName)
-    }
-
-    private get repoExistsMessage() {
-        return `Repo already exists, skipping: ${this.currentRepoName}!`
-    }
-
     private get existsSync() {
         return GitAutocloner.existsSync
     }
@@ -99,8 +97,6 @@ export default class GitAutocloner implements Autocloner {
     private get execSync() {
         return GitAutocloner.execSync
     }
-
-    private readonly regex = /\/([a-zA-Z0-9_.-]+)\.git/
 }
 
 export interface Autocloner {

package/src/modules/NodeAutomodule.ts

@@ -0,0 +1,136 @@
+import { writeFile } from 'fs/promises'
+import path from 'path'
+import pathExists from './pathExists'
+
+export default class NodeAutomodule implements Automodule {
+    public static Class?: AutomoduleConstructor
+    public static pathExists = pathExists
+    public static writeFile = writeFile
+
+    private testSaveDir: string
+    private moduleSaveDir: string
+    private interfaceName: string
+    private implName: string
+
+    protected constructor(options: AutomoduleOptions) {
+        const { testSaveDir, moduleSaveDir, interfaceName, implName } = options
+
+        this.testSaveDir = testSaveDir
+        this.moduleSaveDir = moduleSaveDir
+        this.interfaceName = interfaceName
+        this.implName = implName
+    }
+
+    public static Create(options: AutomoduleOptions) {
+        return new (this.Class ?? this)(options)
+    }
+
+    public async run() {
+        await this.throwIfTestDirDoesNotExist()
+        await this.throwIfModuleDirDoesNotExist()
+
+        await this.createTestFile()
+        await this.createModuleFile()
+    }
+
+    private async throwIfTestDirDoesNotExist() {
+        const testDirExists = await this.pathExists(this.testSaveDir)
+
+        if (!testDirExists) {
+            throw new Error(`testSaveDir does not exist: ${this.testSaveDir}!`)
+        }
+    }
+
+    private async throwIfModuleDirDoesNotExist() {
+        const moduleDirExists = await this.pathExists(this.moduleSaveDir)
+
+        if (!moduleDirExists) {
+            throw new Error(
+                `moduleSaveDir does not exist: ${this.moduleSaveDir}!`
+            )
+        }
+    }
+
+    private async createTestFile() {
+        await this.writeFile(this.testFileName, this.testFilePattern)
+    }
+
+    private get testFileName() {
+        return path.join(this.testSaveDir, `${this.implName}.test.ts`)
+    }
+
+    private async createModuleFile() {
+        await this.writeFile(this.moduleFileName, this.moduleFilePattern)
+    }
+
+    private get moduleFileName() {
+        return path.join(this.moduleSaveDir, `${this.implName}.ts`)
+    }
+
+    private get pathExists() {
+        return NodeAutomodule.pathExists
+    }
+
+    private get writeFile() {
+        return NodeAutomodule.writeFile
+    }
+
+    private get testFilePattern() {
+        return `
+            import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
+            import ${this.implName}, { ${this.interfaceName} } from '../../modules/${this.implName}'
+
+            export default class ${this.implName}Test extends AbstractSpruceTest {
+                private static instance: ${this.interfaceName}
+                
+                protected static async beforeEach() {
+                    await super.beforeEach()
+                    
+                    this.instance = this.${this.implName}()
+                }
+                
+                @test()
+                protected static async createsInstance() {
+                    assert.isTruthy(this.instance, 'Failed to create instance!')
+                }
+                
+                private static ${this.implName}() {
+                    return ${this.implName}.Create()
+                }
+            }
+        `
+    }
+
+    private get moduleFilePattern() {
+        return `
+            export default class ${this.implName} implements ${this.interfaceName} {
+                public static Class?: ${this.interfaceName}Constructor
+                
+                protected constructor() {}
+                
+                public static Create() {
+                    return new (this.Class ?? this)()
+                }
+            }
+
+            export interface ${this.interfaceName} {}
+
+            export type ${this.interfaceName}Constructor = new () => ${this.interfaceName}
+        `
+    }
+}
+
+export interface Automodule {
+    run(): Promise<void>
+}
+
+export type AutomoduleConstructor = new (
+    options: AutomoduleOptions
+) => Automodule
+
+export interface AutomoduleOptions {
+    testSaveDir: string
+    moduleSaveDir: string
+    interfaceName: string
+    implName: string
+}

package/src/modules/PackageJsonUpdater.ts

@@ -0,0 +1,13 @@
+export default class PackageJsonUpdater implements JsonUpdater {
+    public static Class?: JsonUpdateConstructor
+
+    protected constructor() {}
+
+    public static Create() {
+        return new (this.Class ?? this)()
+    }
+}
+
+export interface JsonUpdater {}
+
+export type JsonUpdateConstructor = new () => JsonUpdater

package/src/modules/pathExists.ts

@@ -0,0 +1,10 @@
+import { access } from 'fs/promises'
+
+export default async function pathExists(path: string) {
+    try {
+        await access(path)
+        return true
+    } catch {
+        return false
+    }
+}

package/src/scripts/runAutomodule.ts

@@ -0,0 +1,22 @@
+import NodeAutomodule from '../modules/NodeAutomodule'
+
+async function main() {
+    console.log('\nRunning automodule...')
+
+    const instance = NodeAutomodule.Create({
+        testSaveDir:
+            '/Users/ericthecurious/dev/meta-node/src/__tests__/modules',
+        moduleSaveDir: '/Users/ericthecurious/dev/meta-node/src/modules',
+        interfaceName: 'Autocomponent',
+        implName: 'ReactAutocomponent',
+    })
+
+    await instance.run()
+
+    console.log('Finished running automodule!\n')
+}
+
+main().catch((err) => {
+    console.error(err)
+    process.exit(1)
+})

package/src/scripts/runAutopackage.ts

@@ -1,8 +1,8 @@
 import { execSync } from 'child_process'
 import NpmAutopackage from '../modules/NpmAutopackage'
 
-async function run() {
-    console.log('Running...')
+async function main() {
+    console.log('Running autopackage...')
 
     await NpmAutopackage.Create({
         name: 'node-xyz',
@@ -19,7 +19,7 @@ async function run() {
     process.exit(0)
 }
 
-run().catch((err) => {
+main().catch((err) => {
     console.error(err)
     process.exit(1)
 })

package/src/testDoubles/Automodule/FakeAutomodule.ts

@@ -0,0 +1,19 @@
+import { Automodule, AutomoduleOptions } from '../../modules/NodeAutomodule'
+
+export default class FakeAutomodule implements Automodule {
+    public static callsToConstructor: AutomoduleOptions[] = []
+    public static numCallsToRun = 0
+
+    public constructor(options: AutomoduleOptions) {
+        FakeAutomodule.callsToConstructor.push(options)
+    }
+
+    public async run() {
+        FakeAutomodule.numCallsToRun++
+    }
+
+    public static resetTestDouble() {
+        this.callsToConstructor = []
+        this.numCallsToRun = 0
+    }
+}

package/src/testDoubles/fs/fakePathExists.ts

@@ -0,0 +1,9 @@
+export let pathShouldExist: Record<string, boolean> = {}
+
+export function setPathShouldExist(path: string, shouldExist: boolean) {
+    pathShouldExist[path] = shouldExist
+}
+
+export default async function fakePathExists(path: string) {
+    return pathShouldExist[path]
+}