@neurodevs/meta-node 0.1.0 → 0.3.0

package/src/modules/NpmAutopackage.ts

@@ -1,88 +1,311 @@
 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) {
-        const instance = new (this.Class ?? this)(options)
-        await instance.createPackage()
+        return new (this.Class ?? this)(options)
+    }
+
+    public async run() {
+        this.throwIfGithubTokenNotInEnv()
+
+        await this.createRepoInGithubOrg()
 
-        return instance
+        this.chdirToInstallDir()
+        this.cloneGitRepo()
+        this.chdirToPackageDir()
+        this.spruceCreateModule()
+        this.updatePackage()
+        this.updateGitignore()
+        this.setupVscode()
     }
 
-    public async createPackage() {
-        this.execCreateModule()
-        this.execGitSetup()
-        this.execSetupVscode()
+    private throwIfGithubTokenNotInEnv() {
+        if (!this.githubToken) {
+            throw new Error('\n\nPlease set process.env.GITHUB_TOKEN!\n')
+        }
     }
 
-    private execCreateModule() {
-        this.chdirToInstallDir()
-        this.exec(this.createModuleCmd)
+    private get githubToken() {
+        return process.env.GITHUB_TOKEN
     }
 
-    private execGitSetup() {
-        this.chdirToNewPackageDir()
+    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',
+                }),
+            }
+        )
+    }
 
-        this.gitInit()
-        this.gitAdd()
-        this.gitCommitCreateModule()
-        this.gitRemoteAddOrigin()
+    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,24 +316,25 @@ 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 {
-    createPackage(): Promise<void>
+    run(): Promise<void>
 }
 
 export interface AutopackageOptions {
@@ -119,6 +343,11 @@ export interface AutopackageOptions {
     gitNamespace: string
     npmNamespace: string
     installDir: string
+    keywords?: string[]
+    license?: string
+    author?: string
 }
 
-export type AutopackageConstructor = new () => Autopackage
+export type AutopackageConstructor = new (
+    options: AutopackageOptions
+) => Autopackage

package/src/scripts/runAutopackage.ts

@@ -5,11 +5,13 @@ 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...')

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 run() {
+        FakeAutopackage.numCallsToCreatePackage++
+    }
+
+    public static resetTestDouble() {
+        this.callsToConstructor = []
+        this.numCallsToCreatePackage = 0
+    }
+}

package/build/__tests__/modules/PackageJsonUpdater.test.d.ts

@@ -1,7 +0,0 @@
-import AbstractSpruceTest from '@sprucelabs/test-utils';
-export default class PackageJsonUpdaterTest extends AbstractSpruceTest {
-    private static instance;
-    protected static beforeEach(): Promise<void>;
-    protected static createsInstance(): Promise<void>;
-    private static PackageJsonUpdater;
-}

package/build/__tests__/modules/PackageJsonUpdater.test.js

@@ -1,63 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_utils_1 = __importStar(require("@sprucelabs/test-utils"));
-const PackageJsonUpdater_1 = __importDefault(require("../../modules/PackageJsonUpdater"));
-class PackageJsonUpdaterTest extends test_utils_1.default {
-    static async beforeEach() {
-        await super.beforeEach();
-        this.instance = this.PackageJsonUpdater();
-    }
-    static async createsInstance() {
-        test_utils_1.assert.isTruthy(this.instance, 'Failed to create instance!');
-    }
-    static PackageJsonUpdater() {
-        return PackageJsonUpdater_1.default.Create();
-    }
-}
-exports.default = PackageJsonUpdaterTest;
-__decorate([
-    (0, test_utils_1.test)()
-], PackageJsonUpdaterTest, "createsInstance", null);
-//# sourceMappingURL=PackageJsonUpdater.test.js.map

package/build/__tests__/modules/PackageJsonUpdater.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PackageJsonUpdater.test.js","sourceRoot":"","sources":["../../../src/__tests__/modules/PackageJsonUpdater.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qEAAyE;AACzE,0FAEyC;AAEzC,MAAqB,sBAAuB,SAAQ,oBAAkB;IAGxD,MAAM,CAAC,KAAK,CAAC,UAAU;QAC7B,MAAM,KAAK,CAAC,UAAU,EAAE,CAAA;QAExB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAA;IAC7C,CAAC;IAGsB,AAAb,MAAM,CAAC,KAAK,CAAC,eAAe;QAClC,mBAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAA;IAChE,CAAC;IAEO,MAAM,CAAC,kBAAkB;QAC7B,OAAO,4BAAkB,CAAC,MAAM,EAAE,CAAA;IACtC,CAAC;CACJ;AAjBD,yCAiBC;AAP0B;IADtB,IAAA,iBAAI,GAAE;mDAGN"}

package/build/modules/PackageJsonUpdater.d.ts

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

package/build/modules/PackageJsonUpdater.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class PackageJsonUpdater {
-    constructor() { }
-    static Create() {
-        return new (this.Class ?? this)();
-    }
-}
-exports.default = PackageJsonUpdater;
-//# sourceMappingURL=PackageJsonUpdater.js.map

package/build/modules/PackageJsonUpdater.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PackageJsonUpdater.js","sourceRoot":"","sources":["../../src/modules/PackageJsonUpdater.ts"],"names":[],"mappings":";;AAAA,MAAqB,kBAAkB;IAGnC,gBAAyB,CAAC;IAEnB,MAAM,CAAC,MAAM;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,EAAE,CAAA;IACrC,CAAC;CACJ;AARD,qCAQC"}

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

@@ -1,23 +0,0 @@
-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/modules/PackageJsonUpdater.ts

@@ -1,13 +0,0 @@
-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