@neurodevs/meta-node 0.0.1

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

@@ -0,0 +1,124 @@
+import AbstractSpruceTest, {
+    test,
+    assert,
+    generateId,
+} from '@sprucelabs/test-utils'
+import NpmAutopackage, {
+    Autopackage,
+    AutopackageOptions,
+} from '../../modules/NpmAutopackage'
+
+export default class NpmAutopackageTest extends AbstractSpruceTest {
+    private static instance: Autopackage
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.fakeExecToPreventActual()
+        this.fakeChdirToPreventActual()
+
+        this.instance = await this.NpmAutopackage()
+    }
+
+    @test()
+    protected static async createsNpmAutopackageInstance() {
+        assert.isTruthy(this.instance, 'Should create an instance!')
+    }
+
+    @test()
+    protected static async firstCallsChdirToInstallDir() {
+        assert.isEqual(
+            this.callsToChdir[0],
+            this.installDir,
+            'Should have changed dir!'
+        )
+    }
+
+    @test()
+    protected static async thenCallsSpruceCreateModule() {
+        assert.isEqual(
+            this.callsToExecSync[0],
+            this.createModuleCmd,
+            'Should have called "spruce create.module"!'
+        )
+    }
+
+    @test()
+    protected static async thenCallsChdirToNewlyCreatedDir() {
+        assert.isEqual(
+            this.callsToChdir[1],
+            `${this.installDir}/${this.packageName}`,
+            'Should have changed dir!'
+        )
+    }
+
+    @test()
+    protected static async thenSetsUpNewGitRepo() {
+        assert.isEqualDeep(
+            this.callsToExecSync.slice(1, 5),
+            [
+                'git init',
+                'git add .',
+                'git commit -m "patch: create module"',
+                `git remote add origin "https://github.com/${this.gitNamespace}/${this.packageName}.git"`,
+            ],
+            'Should have called "git init"!'
+        )
+    }
+
+    @test()
+    protected static async thenCallsSpruceSetupVscode() {
+        assert.isEqual(
+            this.callsToExecSync[5],
+            'spruce setup.vscode --all true',
+            'Should have called "spruce setup.vscode"!'
+        )
+    }
+
+    @test()
+    protected static async thenGitCommitsVscodeChanges() {
+        assert.isEqualDeep(
+            this.callsToExecSync.slice(6, 8),
+            ['git add .', 'git commit -m "patch: setup vscode"'],
+            'Should have committed vscode changes!'
+        )
+    }
+
+    private static fakeExecToPreventActual() {
+        // @ts-ignore
+        NpmAutopackage.execSync = (cmd: string) => {
+            this.callsToExecSync.push(cmd)
+        }
+        this.callsToExecSync = []
+    }
+
+    private static fakeChdirToPreventActual() {
+        NpmAutopackage.chdir = (dir: string) => {
+            this.callsToChdir.push(dir)
+        }
+        this.callsToChdir = []
+    }
+
+    private static callsToExecSync: string[] = []
+    private static callsToChdir: string[] = []
+
+    private static readonly packageName = generateId()
+    private static readonly packageDescription = generateId()
+    private static readonly gitNamespace = generateId()
+    private static readonly npmNamespace = generateId()
+    private static readonly installDir = generateId()
+
+    private static readonly createModuleCmd = `spruce create.module --name "${this.packageName}" --destination "${this.installDir}/${this.packageName}" --description "${this.packageDescription}"`
+
+    private static readonly defaultOptions = {
+        name: this.packageName,
+        description: this.packageDescription,
+        gitNamespace: this.gitNamespace,
+        npmNamespace: this.npmNamespace,
+        installDir: this.installDir,
+    }
+
+    private static NpmAutopackage(options?: Partial<AutopackageOptions>) {
+        return NpmAutopackage.Create({ ...this.defaultOptions, ...options })
+    }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+// Autopackage
+
+export { default as NpmAutopackage } from './modules/NpmAutopackage'
+export * from './modules/NpmAutopackage'
+
+// Autocloner
+
+export { default as GitAutocloner } from './modules/GitAutocloner'
+export * from './modules/GitAutocloner'
+
+export { default as FakeAutocloner } from './testDoubles/Autocloner/FakeAutocloner'
+export * from './testDoubles/Autocloner/FakeAutocloner'

package/src/modules/GitAutocloner.ts

@@ -0,0 +1,115 @@
+import { execSync } from 'child_process'
+import { existsSync } from 'fs'
+import { chdir } from 'process'
+
+export default class GitAutocloner implements Autocloner {
+    public static Class?: AutoclonerConstructor
+    public static execSync = execSync
+    public static existsSync = existsSync
+
+    private urls!: string[]
+    private dirPath!: string
+    private currentUrl!: string
+    private currentError!: any
+    private log = console
+
+    protected constructor() {}
+
+    public static Create() {
+        return new (this.Class ?? this)()
+    }
+
+    public async run(options: AutoclonerOptions) {
+        const { urls, dirPath } = options
+
+        this.urls = urls
+        this.dirPath = dirPath
+
+        this.throwIfDirPathDoesNotExist()
+        this.changeDirectoryToDirPath()
+        this.cloneReposFromUrls()
+    }
+
+    private throwIfDirPathDoesNotExist() {
+        if (!this.dirPathExists) {
+            throw new Error(this.dirPathDoesNotExistMessage)
+        }
+    }
+
+    private get dirPathDoesNotExistMessage() {
+        return `dirPath does not exist: ${this.dirPath}!`
+    }
+
+    private changeDirectoryToDirPath() {
+        chdir(this.dirPath)
+    }
+
+    private cloneReposFromUrls() {
+        this.urls.forEach((url) => {
+            this.currentUrl = url
+            this.cloneCurrentUrl()
+        })
+    }
+
+    private cloneCurrentUrl() {
+        if (!this.currentRepoExists) {
+            this.tryToCloneRepo()
+        } else {
+            this.log.info(this.repoExistsMessage)
+        }
+    }
+
+    private tryToCloneRepo() {
+        try {
+            this.execSync(`git clone ${this.currentUrl}`)
+        } catch (err: any) {
+            this.currentError = err
+            this.throwGitCloneFailed()
+        }
+    }
+
+    private throwGitCloneFailed() {
+        throw new Error(this.gitCloneFailedMessage)
+    }
+
+    private get gitCloneFailedMessage() {
+        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
+    }
+
+    private get execSync() {
+        return GitAutocloner.execSync
+    }
+
+    private readonly regex = /\/([a-zA-Z0-9_.-]+)\.git/
+}
+
+export interface Autocloner {
+    run(options: AutoclonerOptions): Promise<void>
+}
+
+export type AutoclonerConstructor = new () => Autocloner
+
+export interface AutoclonerOptions {
+    urls: string[]
+    dirPath: string
+}

package/src/modules/NpmAutopackage.ts

@@ -0,0 +1,124 @@
+import { execSync } from 'child_process'
+
+export default class NpmAutopackage implements Autopackage {
+    public static Class?: AutopackageConstructor
+    public static chdir = process.chdir
+    public static execSync = execSync
+
+    private packageName: string
+    private packageDescription: string
+    private gitNamespace: string
+    private installDir: string
+
+    protected constructor(options: AutopackageOptions) {
+        const { name, description, gitNamespace, installDir } = options
+
+        this.packageName = name
+        this.packageDescription = description
+        this.gitNamespace = gitNamespace
+        this.installDir = installDir
+    }
+
+    public static async Create(options: AutopackageOptions) {
+        const instance = new (this.Class ?? this)(options)
+        await instance.createPackage()
+
+        return instance
+    }
+
+    public async createPackage() {
+        this.execCreateModule()
+        this.execGitSetup()
+        this.execSetupVscode()
+    }
+
+    private execCreateModule() {
+        this.chdirToInstallDir()
+        this.exec(this.createModuleCmd)
+    }
+
+    private execGitSetup() {
+        this.chdirToNewPackageDir()
+
+        this.gitInit()
+        this.gitAdd()
+        this.gitCommitCreateModule()
+        this.gitRemoteAddOrigin()
+    }
+
+    private gitInit() {
+        this.exec(this.initCmd)
+    }
+
+    private gitAdd() {
+        this.exec(this.addCmd)
+    }
+
+    private gitCommitCreateModule() {
+        this.exec(this.commitCreateCmd)
+    }
+
+    private gitRemoteAddOrigin() {
+        this.exec(this.addRemoteCmd)
+    }
+
+    private execSetupVscode() {
+        this.exec(this.setupVscodeCmd)
+
+        this.gitAdd()
+        this.gitCommitSetupVscode()
+    }
+
+    private gitCommitSetupVscode() {
+        this.exec(this.commitVscodeCmd)
+    }
+
+    private chdirToInstallDir() {
+        this.chdir(this.installDir)
+    }
+
+    private chdirToNewPackageDir() {
+        this.chdir(this.packageDir)
+    }
+
+    private get packageDir() {
+        return `${this.installDir}/${this.packageName}`
+    }
+
+    private get chdir() {
+        return NpmAutopackage.chdir
+    }
+
+    private get exec() {
+        return NpmAutopackage.execSync
+    }
+
+    private get createModuleCmd() {
+        return `spruce create.module --name "${this.packageName}" --destination "${this.installDir}/${this.packageName}" --description "${this.packageDescription}"`
+    }
+
+    private readonly initCmd = 'git init'
+    private readonly addCmd = 'git add .'
+    private readonly commitCreateCmd = 'git commit -m "patch: create module"'
+
+    private get addRemoteCmd() {
+        return `git remote add origin "https://github.com/${this.gitNamespace}/${this.packageName}.git"`
+    }
+
+    private readonly setupVscodeCmd = 'spruce setup.vscode --all true'
+    private readonly commitVscodeCmd = 'git commit -m "patch: setup vscode"'
+}
+
+export interface Autopackage {
+    createPackage(): Promise<void>
+}
+
+export interface AutopackageOptions {
+    name: string
+    description: string
+    gitNamespace: string
+    npmNamespace: string
+    installDir: string
+}
+
+export type AutopackageConstructor = new () => Autopackage

package/src/scripts/runAutopackage.ts

@@ -0,0 +1,25 @@
+import { execSync } from 'child_process'
+import NpmAutopackage from '../modules/NpmAutopackage'
+
+async function run() {
+    console.log('Running...')
+
+    await NpmAutopackage.Create({
+        name: 'node-xyz',
+        description: 'XYZ, yo',
+        gitNamespace: 'neurodevs',
+        npmNamespace: 'neurodevs',
+        installDir: '/Users/ericthecurious/dev',
+    })
+
+    console.log('Opening in VSCode...')
+    execSync('code .')
+    console.log('Done!')
+
+    process.exit(0)
+}
+
+run().catch((err) => {
+    console.error(err)
+    process.exit(1)
+})

package/src/testDoubles/Autocloner/FakeAutocloner.ts

@@ -0,0 +1,19 @@
+import { Autocloner, AutoclonerOptions } from '../../modules/GitAutocloner'
+
+export default class FakeGitAutocloner implements Autocloner {
+    public static numCallsToConstructor = 0
+    public static callsToRun: AutoclonerOptions[] = []
+
+    public constructor() {
+        FakeGitAutocloner.numCallsToConstructor++
+    }
+
+    public async run(options: AutoclonerOptions) {
+        FakeGitAutocloner.callsToRun.push(options)
+    }
+
+    public static resetTestDouble() {
+        FakeGitAutocloner.numCallsToConstructor = 0
+        FakeGitAutocloner.callsToRun = []
+    }
+}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+	"compilerOptions": {
+		"skipLibCheck": true,
+		"module": "commonjs",
+		"esModuleInterop": true,
+		"target": "ES2020",
+		"lib": [
+			"DOM",
+			"ES2022"
+		],
+		"declaration": true,
+		"noImplicitAny": true,
+		"allowJs": true,
+		"forceConsistentCasingInFileNames": true,
+		"noImplicitReturns": true,
+		"strict": true,
+		"noUnusedLocals": true,
+		"resolveJsonModule": true,
+		"moduleResolution": "node",
+		"sourceMap": false,
+		"outDir": "build",
+		"baseUrl": "src",
+		"experimentalDecorators": true,
+		"paths": {
+			"#spruce/*": [
+				".spruce/*"
+			]
+		}
+	},
+	"include": [
+		"./src/*.ts",
+		"./src/**/*.ts",
+		"./src/.spruce/**/*"
+	],
+	"exclude": [
+		"build",
+		"esm"
+	]
+}