ic-mops 1.12.0 → 2.0.0

package/commands/user.ts

@@ -1,99 +1,108 @@
-import process from 'node:process';
-import chalk from 'chalk';
-import fs from 'node:fs';
-import path from 'node:path';
-import {Buffer} from 'node:buffer';
-import prompts from 'prompts';
-import {deleteSync} from 'del';
-import {mainActor} from '../api/actors.js';
-import {getIdentity, globalConfigDir} from '../mops.js';
-import {encrypt} from '../pem.js';
+import process from "node:process";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import prompts from "prompts";
+import { deleteSync } from "del";
+import { mainActor } from "../api/actors.js";
+import { getIdentity, globalConfigDir } from "../mops.js";
+import { encrypt } from "../pem.js";
 
-export async function getUserProp(prop : string) {
-	let actor = await mainActor();
-	let identity = await getIdentity();
-	if (!identity) {
-		console.log(chalk.red('Error: ') + 'No identity found');
-		process.exit(1);
-	}
-	let res = await actor.getUser(identity.getPrincipal());
-	// @ts-ignore
-	console.log(res[0]?.[prop] || '');
+export async function getUserProp(prop: string) {
+  let actor = await mainActor();
+  let identity = await getIdentity();
+  if (!identity) {
+    console.log(chalk.red("Error: ") + "No identity found");
+    process.exit(1);
+  }
+  let res = await actor.getUser(identity.getPrincipal());
+  // @ts-ignore
+  console.log(res[0]?.[prop] || "");
 }
 
-export async function setUserProp(prop : string, value : string) {
-	let identity = await getIdentity();
-	let actor = await mainActor(identity);
+export async function setUserProp(prop: string, value: string) {
+  let identity = await getIdentity();
+  let actor = await mainActor(identity);
 
-	let res = await actor.setUserProp(prop, value);
-	if ('ok' in res) {
-		console.log(chalk.green('Success!'));
-	}
-	else {
-		console.log(chalk.red('Error: ') + res.err);
-	}
+  let res = await actor.setUserProp(prop, value);
+  if ("ok" in res) {
+    console.log(chalk.green("Success!"));
+  } else {
+    console.log(chalk.red("Error: ") + res.err);
+  }
 }
 
 export async function getPrincipal() {
-	let identity = await getIdentity();
-	if (identity) {
-		console.log(identity.getPrincipal().toText());
-	}
-	else {
-		console.log(chalk.red('Error: ') + 'identity not found. Run ' + chalk.greenBright('mops user import') + ' command.');
-	}
+  let identity = await getIdentity();
+  if (identity) {
+    console.log(identity.getPrincipal().toText());
+  } else {
+    console.log(
+      chalk.red("Error: ") +
+        "identity not found. Run " +
+        chalk.greenBright("mops user import") +
+        " command.",
+    );
+  }
 }
 
 type ImportIdentityOptions = {
-	encrypt : boolean;
+  encrypt: boolean;
 };
 
-export async function importPem(data : string, options : ImportIdentityOptions = {encrypt: true}) {
-	try {
-		if (!fs.existsSync(globalConfigDir)) {
-			fs.mkdirSync(globalConfigDir);
-		}
+export async function importPem(
+  data: string,
+  options: ImportIdentityOptions = { encrypt: true },
+) {
+  try {
+    if (!fs.existsSync(globalConfigDir)) {
+      fs.mkdirSync(globalConfigDir);
+    }
 
-		let password = '';
+    let password = "";
 
-		if (options.encrypt) {
-			let res = await prompts({
-				type: 'invisible',
-				name: 'password',
-				message: 'Enter password to encrypt identity.pem',
-			});
-			password = res.password;
+    if (options.encrypt) {
+      let res = await prompts({
+        type: "invisible",
+        name: "password",
+        message: "Enter password to encrypt identity.pem",
+      });
+      password = res.password;
 
-			if (!password) {
-				let res = await prompts({
-					type: 'confirm',
-					name: 'ok',
-					message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
-				});
-				if (!res.ok) {
-					console.log('aborted');
-					return;
-				}
-			}
-		}
+      if (!password) {
+        let res = await prompts({
+          type: "confirm",
+          name: "ok",
+          message:
+            "Are you sure you don't want to protect your identity.pem with a password?",
+        });
+        if (!res.ok) {
+          console.log("aborted");
+          return;
+        }
+      }
+    }
 
-		let identityPem = path.resolve(globalConfigDir, 'identity.pem');
-		let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
+    let identityPem = path.resolve(globalConfigDir, "identity.pem");
+    let identityPemEncrypted = path.resolve(
+      globalConfigDir,
+      "identity.pem.encrypted",
+    );
 
-		deleteSync([identityPem, identityPemEncrypted], {force: true});
+    deleteSync([identityPem, identityPemEncrypted], { force: true });
 
-		// encrypted
-		if (password) {
-			let encrypted = await encrypt(Buffer.from(data), password);
-			fs.writeFileSync(identityPemEncrypted, encrypted);
-		}
-		// unencrypted
-		else {
-			fs.writeFileSync(identityPem, data);
-		}
-		console.log(chalk.green('Success'));
-	}
-	catch (err) {
-		console.log(chalk.red('Error: ') + err);
-	}
-}
+    // encrypted
+    if (password) {
+      let encrypted = await encrypt(Buffer.from(data), password);
+      fs.writeFileSync(identityPemEncrypted, encrypted);
+    }
+    // unencrypted
+    else {
+      fs.writeFileSync(identityPem, data);
+    }
+    console.log(chalk.green("Success"));
+  } catch (err) {
+    console.log(chalk.red("Error: ") + err);
+  }
+}

package/commands/watch/deployer.ts

@@ -1,155 +1,191 @@
-import chalk from 'chalk';
-import os from 'node:os';
-import {promisify} from 'node:util';
-import {execFile, execSync} from 'node:child_process';
+import chalk from "chalk";
+import os from "node:os";
+import { promisify } from "node:util";
+import { execFile, execSync } from "node:child_process";
 
-import {ErrorChecker} from './error-checker.js';
-import {Generator} from './generator.js';
-import {parallel} from '../../parallel.js';
-import {getRootDir} from '../../mops.js';
+import { ErrorChecker } from "./error-checker.js";
+import { Generator } from "./generator.js";
+import { parallel } from "../../parallel.js";
+import { getRootDir } from "../../mops.js";
 
 export class Deployer {
-	verbose = false;
-	canisters : Record<string, string> = {};
-	status : 'pending' | 'running' | 'syntax-error' | 'dfx-error' | 'error' | 'success' = 'pending';
-	errorChecker : ErrorChecker;
-	generator : Generator;
-	success = 0;
-	errors : string[] = [];
-	aborted = false;
-	controllers = new Map<string, AbortController>();
-	currentRun : Promise<any> | undefined;
-
-	constructor({verbose, canisters, errorChecker, generator} : {verbose : boolean, canisters : Record<string, string>, errorChecker : ErrorChecker, generator : Generator}) {
-		this.verbose = verbose;
-		this.canisters = canisters;
-		this.errorChecker = errorChecker;
-		this.generator = generator;
-	}
-
-	reset() {
-		this.status = 'pending';
-		this.success = 0;
-		this.errors = [];
-	}
-
-	async abortCurrent() {
-		this.aborted = true;
-		for (let controller of this.controllers.values()) {
-			controller.abort();
-		}
-		this.controllers.clear();
-		await this.currentRun;
-		this.reset();
-		this.aborted = false;
-	}
-
-	async run(onProgress : () => void) {
-		await this.abortCurrent();
-
-		if (this.errorChecker.status === 'error') {
-			this.status = 'syntax-error';
-			onProgress();
-			return;
-		}
-
-		if (Object.keys(this.canisters).length === 0) {
-			this.status = 'success';
-			onProgress();
-			return;
-		}
-
-		let rootDir = getRootDir();
-
-		try {
-			execSync('dfx ping', {cwd: rootDir});
-		}
-		catch (error) {
-			this.status = 'dfx-error';
-			onProgress();
-			return;
-		}
-
-		this.status = 'running';
-		onProgress();
-
-		// create canisters (sequentially to avoid DFX errors)
-		let resolve : (() => void) | undefined;
-		this.currentRun = new Promise<void>((res) => resolve = res);
-		for (let canister of Object.keys(this.canisters)) {
-			let controller = new AbortController();
-			let {signal} = controller;
-			this.controllers.set(canister, controller);
-
-			await promisify(execFile)('dfx', ['canister', 'create', canister], {cwd: rootDir, signal}).catch((error) => {
-				if (error.code === 'ABORT_ERR') {
-					return {stderr: ''};
-				}
-				throw error;
-			});
-
-			this.controllers.delete(canister);
-		}
-
-		resolve?.();
-
-		if (this.aborted) {
-			return;
-		}
-
-		this.currentRun = parallel(os.cpus().length, [...Object.keys(this.canisters)], async (canister) => {
-			let controller = new AbortController();
-			let {signal} = controller;
-			this.controllers.set(canister, controller);
-
-			// build
-			if (this.generator.status !== 'success' || !this.generator.canisters[canister]) {
-				await promisify(execFile)('dfx', ['build', canister], {cwd: rootDir, signal}).catch((error) => {
-					if (error.code === 'ABORT_ERR') {
-						return {stderr: ''};
-					}
-					throw error;
-				});
-			}
-
-			// install
-			await promisify(execFile)('dfx', ['canister', 'install', '--mode=auto', '--yes', canister], {cwd: rootDir, signal}).catch((error) => {
-				if (error.code === 'ABORT_ERR') {
-					return {stderr: ''};
-				}
-				throw error;
-			});
-
-			this.success += 1;
-			this.controllers.delete(canister);
-			onProgress();
-		});
-
-		await this.currentRun;
-
-		if (!this.aborted) {
-			this.status = 'success';
-		}
-		onProgress();
-	}
-
-	getOutput() : string {
-		let get = (v : number) => v.toString();
-		let count = (this.status === 'running' ? get : chalk.bold[this.errors.length > 0 ? 'redBright' : 'green'])(this.errors.length || this.success);
-
-		if (this.status === 'pending') {
-			return `Deploy: ${chalk.gray('(pending)')}`;
-		}
-		if (this.status === 'running') {
-			return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
-		}
-		if (this.status === 'syntax-error') {
-			return `Deploy: ${chalk.gray('(errors)')}`;
-		}
-		if (this.status === 'dfx-error') {
-			return `Deploy: ${chalk.gray('(dfx not running)')}`;
-		}
-
-		return `Deploy: ${count}`;
-	}
-}
+  verbose = false;
+  canisters: Record<string, string> = {};
+  status:
+    | "pending"
+    | "running"
+    | "syntax-error"
+    | "dfx-error"
+    | "error"
+    | "success" = "pending";
+  errorChecker: ErrorChecker;
+  generator: Generator;
+  success = 0;
+  errors: string[] = [];
+  aborted = false;
+  controllers = new Map<string, AbortController>();
+  currentRun: Promise<any> | undefined;
+
+  constructor({
+    verbose,
+    canisters,
+    errorChecker,
+    generator,
+  }: {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    errorChecker: ErrorChecker;
+    generator: Generator;
+  }) {
+    this.verbose = verbose;
+    this.canisters = canisters;
+    this.errorChecker = errorChecker;
+    this.generator = generator;
+  }
+
+  reset() {
+    this.status = "pending";
+    this.success = 0;
+    this.errors = [];
+  }
+
+  async abortCurrent() {
+    this.aborted = true;
+    for (let controller of this.controllers.values()) {
+      controller.abort();
+    }
+    this.controllers.clear();
+    await this.currentRun;
+    this.reset();
+    this.aborted = false;
+  }
+
+  async run(onProgress: () => void) {
+    await this.abortCurrent();
+
+    if (this.errorChecker.status === "error") {
+      this.status = "syntax-error";
+      onProgress();
+      return;
+    }
+
+    if (Object.keys(this.canisters).length === 0) {
+      this.status = "success";
+      onProgress();
+      return;
+    }
+
+    let rootDir = getRootDir();
+
+    try {
+      execSync("dfx ping", { cwd: rootDir });
+    } catch (error) {
+      this.status = "dfx-error";
+      onProgress();
+      return;
+    }
+
+    this.status = "running";
+    onProgress();
+
+    // create canisters (sequentially to avoid DFX errors)
+    let resolve: (() => void) | undefined;
+    this.currentRun = new Promise<void>((res) => (resolve = res));
+    for (let canister of Object.keys(this.canisters)) {
+      let controller = new AbortController();
+      let { signal } = controller;
+      this.controllers.set(canister, controller);
+
+      await promisify(execFile)("dfx", ["canister", "create", canister], {
+        cwd: rootDir,
+        signal,
+      }).catch((error) => {
+        if (error.code === "ABORT_ERR") {
+          return { stderr: "" };
+        }
+        throw error;
+      });
+
+      this.controllers.delete(canister);
+    }
+
+    resolve?.();
+
+    if (this.aborted) {
+      return;
+    }
+
+    this.currentRun = parallel(
+      os.cpus().length,
+      [...Object.keys(this.canisters)],
+      async (canister) => {
+        let controller = new AbortController();
+        let { signal } = controller;
+        this.controllers.set(canister, controller);
+
+        // build
+        if (
+          this.generator.status !== "success" ||
+          !this.generator.canisters[canister]
+        ) {
+          await promisify(execFile)("dfx", ["build", canister], {
+            cwd: rootDir,
+            signal,
+          }).catch((error) => {
+            if (error.code === "ABORT_ERR") {
+              return { stderr: "" };
+            }
+            throw error;
+          });
+        }
+
+        // install
+        await promisify(execFile)(
+          "dfx",
+          ["canister", "install", "--mode=auto", "--yes", canister],
+          { cwd: rootDir, signal },
+        ).catch((error) => {
+          if (error.code === "ABORT_ERR") {
+            return { stderr: "" };
+          }
+          throw error;
+        });
+
+        this.success += 1;
+        this.controllers.delete(canister);
+        onProgress();
+      },
+    );
+
+    await this.currentRun;
+
+    if (!this.aborted) {
+      this.status = "success";
+    }
+    onProgress();
+  }
+
+  getOutput(): string {
+    let get = (v: number) => v.toString();
+    let count = (
+      this.status === "running"
+        ? get
+        : chalk.bold[this.errors.length > 0 ? "redBright" : "green"]
+    )(this.errors.length || this.success);
+
+    if (this.status === "pending") {
+      return `Deploy: ${chalk.gray("(pending)")}`;
+    }
+    if (this.status === "running") {
+      return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray("(running)")}`;
+    }
+    if (this.status === "syntax-error") {
+      return `Deploy: ${chalk.gray("(errors)")}`;
+    }
+    if (this.status === "dfx-error") {
+      return `Deploy: ${chalk.gray("(dfx not running)")}`;
+    }
+
+    return `Deploy: ${count}`;
+  }
+}