@neurodevs/meta-node 0.0.1 → 0.2.0

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/NpmAutopackage.ts

@@ -1,22 +1,41 @@
 import { execSync } from 'child_process'
+import fs from 'fs'
 
 export default class NpmAutopackage implements Autopackage {
     public static Class?: AutopackageConstructor
     public static chdir = process.chdir
     public static execSync = execSync
+    public static existsSync = fs.existsSync
+    public static fetch = globalThis.fetch
+    public static readFileSync = fs.readFileSync
+    public static writeFileSync = fs.writeFileSync
 
     private packageName: string
     private packageDescription: string
     private gitNamespace: string
     private installDir: string
+    private keywords?: string[]
+    private license?: string
+    private author?: string
 
     protected constructor(options: AutopackageOptions) {
-        const { name, description, gitNamespace, installDir } = options
+        const {
+            name,
+            description,
+            gitNamespace,
+            installDir,
+            license,
+            author,
+            keywords,
+        } = options
 
         this.packageName = name
         this.packageDescription = description
         this.gitNamespace = gitNamespace
         this.installDir = installDir
+        this.keywords = keywords
+        this.license = license
+        this.author = author
     }
 
     public static async Create(options: AutopackageOptions) {
@@ -27,62 +46,269 @@ export default class NpmAutopackage implements Autopackage {
     }
 
     public async createPackage() {
-        this.execCreateModule()
-        this.execGitSetup()
-        this.execSetupVscode()
-    }
+        this.throwIfGithubTokenNotInEnv()
+
+        await this.createRepoInGithubOrg()
 
-    private execCreateModule() {
         this.chdirToInstallDir()
-        this.exec(this.createModuleCmd)
+        this.cloneGitRepo()
+        this.chdirToPackageDir()
+        this.spruceCreateModule()
+        this.updatePackage()
+        this.updateGitignore()
+        this.setupVscode()
     }
 
-    private execGitSetup() {
-        this.chdirToNewPackageDir()
+    private throwIfGithubTokenNotInEnv() {
+        if (!this.githubToken) {
+            throw new Error('\n\nPlease set process.env.GITHUB_TOKEN!\n')
+        }
+    }
+
+    private get githubToken() {
+        return process.env.GITHUB_TOKEN
+    }
 
-        this.gitInit()
-        this.gitAdd()
-        this.gitCommitCreateModule()
-        this.gitRemoteAddOrigin()
+    private async createRepoInGithubOrg() {
+        await this.fetch(
+            `https://api.github.com/orgs/${this.gitNamespace}/repos`,
+            {
+                method: 'POST',
+                headers: {
+                    Authorization: `token ${this.githubToken}`,
+                    Accept: 'application/vnd.github+json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    name: this.packageName,
+                    private: false,
+                    description: this.packageDescription,
+                    auto_init: true,
+                    gitignore_template: 'Node',
+                    license_template: 'mit',
+                }),
+            }
+        )
+    }
+
+    private chdirToInstallDir() {
+        this.chdir(this.installDir)
     }
 
-    private gitInit() {
-        this.exec(this.initCmd)
+    private cloneGitRepo() {
+        if (!this.packageDirExists) {
+            this.exec(`git clone ${this.gitUrl}`)
+        }
     }
 
-    private gitAdd() {
-        this.exec(this.addCmd)
+    private get packageDirExists() {
+        return this.existsSync(this.packageDir)
     }
 
-    private gitCommitCreateModule() {
-        this.exec(this.commitCreateCmd)
+    private get packageDir() {
+        return `${this.installDir}/${this.packageName}`
     }
 
-    private gitRemoteAddOrigin() {
-        this.exec(this.addRemoteCmd)
+    private get gitUrl() {
+        return `https://github.com/${this.gitNamespace}/${this.packageName}.git`
     }
 
-    private execSetupVscode() {
-        this.exec(this.setupVscodeCmd)
+    private chdirToPackageDir() {
+        this.chdir(this.packageDir)
+    }
 
-        this.gitAdd()
-        this.gitCommitSetupVscode()
+    private spruceCreateModule() {
+        if (!this.packageJsonExists) {
+            this.execSpruceCreateModule()
+            this.commitCreatePackage()
+        }
     }
 
-    private gitCommitSetupVscode() {
-        this.exec(this.commitVscodeCmd)
+    private get packageJsonExists() {
+        return this.existsSync(this.packageJsonPath)
     }
 
-    private chdirToInstallDir() {
-        this.chdir(this.installDir)
+    private get packageJsonPath() {
+        return `${this.packageDir}/package.json`
     }
 
-    private chdirToNewPackageDir() {
-        this.chdir(this.packageDir)
+    private execSpruceCreateModule() {
+        this.exec(
+            `spruce create.module --name "${this.packageName}" --destination "${this.installDir}/${this.packageName}" --description "${this.packageDescription}"`
+        )
     }
 
-    private get packageDir() {
-        return `${this.installDir}/${this.packageName}`
+    private commitCreatePackage() {
+        this.gitAddAll()
+        this.gitCommitCreatePackage()
+        this.gitPush()
+    }
+
+    private gitAddAll() {
+        this.exec('git add .')
+    }
+
+    private gitCommitCreatePackage() {
+        this.exec('git commit -m "patch: create package"')
+    }
+
+    private gitPush() {
+        this.exec('git push')
+    }
+
+    private updatePackage() {
+        if (!this.packageUpdated) {
+            this.updatePackageJson()
+            this.commitUpdatePackage()
+        }
+    }
+
+    private get packageUpdated() {
+        return this.pkg.name === `@${this.scopedPackage}`
+    }
+
+    private get pkg() {
+        const raw = this.readFileSync(this.packageJsonPath, {
+            encoding: 'utf-8',
+        })
+        return JSON.parse(raw)
+    }
+
+    private updatePackageJson() {
+        const updated = { ...this.pkg, ...this.updatedJsonFile }
+        const ordered = this.orderJsonKeys(updated, [
+            'name',
+            'version',
+            'description',
+            'keywords',
+            'license',
+            'author',
+            'homepage',
+            'repository',
+            'bugs',
+            'main',
+            'scripts',
+            'dependencies',
+            'devDependencies',
+            'jest',
+            'skill',
+        ])
+
+        this.writeFileSync(
+            this.packageJsonPath,
+            JSON.stringify(ordered, null, 2) + '\n',
+            { encoding: 'utf-8' }
+        )
+    }
+
+    private get updatedJsonFile() {
+        return {
+            name: `@${this.scopedPackage}`,
+            keywords: this.keywords ?? [],
+            license: this.license,
+            author: this.author,
+            main: 'build/index.js',
+            homepage: `https://github.com/${this.gitNamespace}/${this.packageName}`,
+            repository: {
+                type: 'git',
+                url: `git+https://github.com/${this.gitNamespace}/${this.packageName}.git`,
+            },
+            bugs: {
+                url: `https://github.com/${this.gitNamespace}/${this.packageName}/issues`,
+            },
+            dependencies: {},
+        }
+    }
+
+    private get scopedPackage() {
+        return `${this.gitNamespace}/${this.packageName}`
+    }
+
+    private orderJsonKeys(json: Record<string, unknown>, keyOrder: string[]) {
+        const ordered: Record<string, any> = {}
+
+        for (const key of keyOrder) {
+            if (key in json) {
+                ordered[key] = json[key]
+            }
+        }
+
+        const remainingKeys = Object.keys(json)
+            .filter((k) => !keyOrder.includes(k))
+            .sort()
+
+        for (const key of remainingKeys) {
+            ordered[key] = json[key]
+        }
+
+        return ordered
+    }
+
+    private commitUpdatePackage() {
+        this.gitAddAll()
+        this.gitCommitUpdatePackage()
+        this.gitPush()
+    }
+
+    private gitCommitUpdatePackage() {
+        this.exec('git commit -m "patch: update package"')
+    }
+
+    private updateGitignore() {
+        if (!this.gitignoreUpdated) {
+            this.writeFileSync(this.gitignorePath, '\nbuild/\n', {
+                encoding: 'utf-8',
+                flag: 'a',
+            })
+            this.commitUpdateGitignore()
+        }
+    }
+
+    private get gitignoreUpdated() {
+        const content = this.readFileSync(this.gitignorePath, {
+            encoding: 'utf-8',
+        })
+        const lines = content.split(/\r?\n/).map((line) => line.trim())
+        return lines.includes('build/')
+    }
+
+    private get gitignorePath() {
+        return `${this.packageDir}/.gitignore`
+    }
+
+    private commitUpdateGitignore() {
+        this.gitAddAll()
+        this.gitCommitUpdateGitignore()
+        this.gitPush()
+    }
+
+    private gitCommitUpdateGitignore() {
+        this.exec('git commit -m "patch: add build dir to gitignore"')
+    }
+
+    private setupVscode() {
+        if (!this.vscodeSettingsExists) {
+            this.spruceSetupVscode()
+            this.commitSetupVscode()
+        }
+    }
+
+    private get vscodeSettingsExists() {
+        return this.existsSync(`${this.packageDir}/.vscode/settings.json`)
+    }
+
+    private spruceSetupVscode() {
+        this.exec('spruce setup.vscode --all true')
+    }
+
+    private commitSetupVscode() {
+        this.gitAddAll()
+        this.gitCommitSetup()
+        this.gitPush()
+    }
+
+    private gitCommitSetup() {
+        this.exec('git commit -m "patch: setup vscode"')
     }
 
     private get chdir() {
@@ -93,20 +319,21 @@ export default class NpmAutopackage implements Autopackage {
         return NpmAutopackage.execSync
     }
 
-    private get createModuleCmd() {
-        return `spruce create.module --name "${this.packageName}" --destination "${this.installDir}/${this.packageName}" --description "${this.packageDescription}"`
+    private get existsSync() {
+        return NpmAutopackage.existsSync
     }
 
-    private readonly initCmd = 'git init'
-    private readonly addCmd = 'git add .'
-    private readonly commitCreateCmd = 'git commit -m "patch: create module"'
+    private get fetch() {
+        return NpmAutopackage.fetch
+    }
 
-    private get addRemoteCmd() {
-        return `git remote add origin "https://github.com/${this.gitNamespace}/${this.packageName}.git"`
+    private get readFileSync() {
+        return NpmAutopackage.readFileSync
     }
 
-    private readonly setupVscodeCmd = 'spruce setup.vscode --all true'
-    private readonly commitVscodeCmd = 'git commit -m "patch: setup vscode"'
+    private get writeFileSync() {
+        return NpmAutopackage.writeFileSync
+    }
 }
 
 export interface Autopackage {
@@ -119,6 +346,9 @@ export interface AutopackageOptions {
     gitNamespace: string
     npmNamespace: string
     installDir: string
+    keywords?: string[]
+    license?: string
+    author?: string
 }
 
 export type AutopackageConstructor = new () => Autopackage

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,15 +1,17 @@
 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',
-        description: 'XYZ, yo',
+        name: 'node-osf',
+        description: 'Node.js client for the Open Science Framework (OSF) API',
         gitNamespace: 'neurodevs',
         npmNamespace: 'neurodevs',
         installDir: '/Users/ericthecurious/dev',
+        license: 'MIT',
+        author: 'Eric Yates <hello@ericthecurious.com>',
     })
 
     console.log('Opening in VSCode...')
@@ -19,7 +21,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/Autopackage/FakeAutopackage.ts

@@ -0,0 +1,19 @@
+import { Autopackage, AutopackageOptions } from '../../modules/NpmAutopackage'
+
+export default class FakeAutopackage implements Autopackage {
+    public static callsToConstructor: AutopackageOptions[] = []
+    public static numCallsToCreatePackage = 0
+
+    public constructor(options: AutopackageOptions) {
+        FakeAutopackage.callsToConstructor.push(options)
+    }
+
+    public async createPackage() {
+        FakeAutopackage.numCallsToCreatePackage++
+    }
+
+    public static resetTestDouble() {
+        this.callsToConstructor = []
+        this.numCallsToCreatePackage = 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]
+}

package/src/testDoubles/fs/fakeWriteFile.ts

@@ -0,0 +1,9 @@
+export let callsToWriteFile: { file: string; data: string }[] = []
+
+export function resetCallsToWriteFile() {
+    callsToWriteFile = []
+}
+
+export default async function fakeWriteFile(file: string, data: string) {
+    callsToWriteFile.push({ file, data })
+}