@prosopo/scripts 3.0.11 → 3.0.13

package/dist/cjs/util/exec.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_child_process = require("node:child_process");
+const node_process = require("node:process");
+const exec = (command, options) => {
+  let { pipe, printCmd } = options || {};
+  pipe = pipe === void 0 || pipe;
+  printCmd = printCmd === void 0 || printCmd;
+  if (printCmd) {
+    console.log(`[exec] ${command}`);
+  }
+  const prc = node_child_process.spawn(command, {
+    shell: true
+  });
+  if (pipe || pipe === void 0) {
+    prc.stdout.pipe(process.stdout);
+    prc.stderr.pipe(process.stderr);
+  }
+  node_process.stdin.pipe(prc.stdin);
+  const stdoutData = [];
+  const stderrData = [];
+  prc.stdout.on("data", (data) => {
+    stdoutData.push(data.toString());
+  });
+  prc.stderr.on("data", (data) => {
+    stderrData.push(data.toString());
+  });
+  return new Promise((resolve, reject) => {
+    prc.on("close", (code) => {
+      if (pipe || pipe === void 0) {
+        console.log("");
+      }
+      const output = {
+        stdout: stdoutData.join(""),
+        stderr: stderrData.join(""),
+        code
+      };
+      if (code === 0) {
+        resolve(output);
+      } else {
+        reject(output);
+      }
+    });
+  });
+};
+exports.exec = exec;

package/dist/cjs/util/fluxLogDappDetails.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function extractReferrersFromLogs(logsText) {
+  const urls = [
+    ...logsText.split("\n").reduce((accumulator, line) => {
+      const matches = line.match(/"(https?:\/\/[^"]+)"/g);
+      if (matches) {
+        for (const match of matches) {
+          const url = match.substring(1, match.length - 1);
+          accumulator.add(url);
+        }
+      }
+      return accumulator;
+    }, /* @__PURE__ */ new Set())
+  ];
+  return urls.join("           ");
+}
+exports.extractReferrersFromLogs = extractReferrersFromLogs;

package/dist/cjs/util/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const loadContractFiles = require("./loadContractFiles.cjs");
+const updateEnv = require("./updateEnv.cjs");
+const exec = require("./exec.cjs");
+const fluxLogDappDetails = require("./fluxLogDappDetails.cjs");
+exports.AbiJSON = loadContractFiles.AbiJSON;
+exports.Wasm = loadContractFiles.Wasm;
+exports.findEnvFiles = updateEnv.findEnvFiles;
+exports.updateDemoHTMLFiles = updateEnv.updateDemoHTMLFiles;
+exports.updateEnvFiles = updateEnv.updateEnvFiles;
+exports.exec = exec.exec;
+exports.extractReferrersFromLogs = fluxLogDappDetails.extractReferrersFromLogs;

package/dist/cjs/util/loadContractFiles.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const apiContract = require("@polkadot/api-contract");
+const util = require("@polkadot/util");
+const common = require("@prosopo/common");
+const fse = require("fs-extra");
+const __dirname$1 = path.resolve();
+async function AbiJSON(filePath) {
+  const resolvedFilePath = path.resolve(__dirname$1, filePath);
+  await fse.ensureFile(resolvedFilePath);
+  const fileExists = await fse.pathExists(resolvedFilePath);
+  if (fileExists) {
+    const json = JSON.parse(
+      await fse.readFile(resolvedFilePath, {
+        encoding: "utf8"
+      })
+    );
+    return new apiContract.Abi(json);
+  }
+  throw new common.ProsopoError("FS.FILE_NOT_FOUND", {
+    context: { error: `File ${filePath} does not exist` }
+  });
+}
+async function Wasm(filePath) {
+  const resolvedFilePath = path.resolve(__dirname$1, filePath);
+  await fse.ensureFile(resolvedFilePath);
+  const fileExists = await fse.pathExists(resolvedFilePath);
+  if (fileExists) {
+    const wasm = `0x${fse.readFileSync(resolvedFilePath).toString("hex")}`;
+    const wasmBytes = util.hexToU8a(wasm);
+    if (util.isWasm(wasmBytes)) {
+      return wasmBytes;
+    }
+    console.error(`Error loading contract wasm: ${wasm.slice(0, 10)}...`);
+    process.exit(1);
+  } else {
+    throw new common.ProsopoError("FS.FILE_NOT_FOUND", {
+      context: { error: `File ${filePath} does not exist` }
+    });
+  }
+}
+exports.AbiJSON = AbiJSON;
+exports.Wasm = Wasm;

package/dist/cjs/util/updateEnv.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs");
+const path = require("node:path");
+const dotenv = require("@prosopo/dotenv");
+const util = require("@prosopo/util");
+const dotenv$1 = require("dotenv");
+const fg = require("fast-glob");
+const ignore = [
+  "**/node_modules/**",
+  "node_modules/**",
+  "../../**/node_modules/**",
+  "../node_modules/**",
+  "../../node_modules/**"
+];
+const __dirname$1 = path.resolve();
+async function findEnvFiles(logger, cwd) {
+  const env = dotenv.getEnv();
+  const fileName = `.env.${env}`;
+  logger.info(() => ({ msg: "Searching for files" }));
+  return await fg(`${cwd || "../.."}/**/${fileName}`, {
+    ignore
+  });
+}
+async function updateDemoHTMLFiles(varMatchers, varValue, logger) {
+  const files = await fg("../../demos/**/*.html", {
+    ignore
+  });
+  logger.info(() => ({ data: { files }, msg: "HTML files found" }));
+  files.forEach((file) => {
+    const filePath = path.resolve(process.cwd(), file);
+    const contents = fs.readFileSync(filePath).toString();
+    let newContents = contents;
+    for (const varMatcher of varMatchers) {
+      const matches = contents.match(varMatcher);
+      if (matches) {
+        const matchedVar = util.at(matches, 1);
+        logger.info(() => ({ data: { matchedVar }, msg: "matchedVar" }));
+        newContents = contents.replaceAll(matchedVar, varValue);
+        break;
+      }
+    }
+    if (newContents !== contents) {
+      fs.writeFileSync(path.resolve(__dirname$1, filePath), newContents);
+    }
+  });
+}
+async function updateEnvFiles(varNames, varValue, logger, cwd) {
+  const files = await findEnvFiles(logger, cwd);
+  logger.info(() => ({ data: { files }, msg: "Env files found" }));
+  files.forEach((file) => {
+    let write = false;
+    const filePath = path.resolve(cwd || process.cwd(), file);
+    const envConfig = dotenv$1.parse(fs.readFileSync(filePath));
+    for (const varName of varNames) {
+      if (varName in envConfig) {
+        envConfig[varName] = varValue;
+        write = true;
+      }
+    }
+    if (write) {
+      fs.writeFileSync(
+        path.resolve(__dirname$1, filePath),
+        Object.keys(envConfig).map((k) => `${k}=${envConfig[k]}`).join("\n")
+      );
+    }
+  });
+}
+exports.findEnvFiles = findEnvFiles;
+exports.updateDemoHTMLFiles = updateDemoHTMLFiles;
+exports.updateEnvFiles = updateEnvFiles;

package/dist/cli/index.js

@@ -1,108 +1,105 @@
 import path from "node:path";
 import { isHex } from "@polkadot/util";
-import { LogLevel, getLogger } from "@prosopo/common";
-import { parseLogLevel } from "@prosopo/common";
-import { getScriptsPkgDir } from "@prosopo/config";
-import { getEnv, loadEnv } from "@prosopo/dotenv";
-import { decodeProcaptchaOutput, encodeProcaptchaOutput } from "@prosopo/types";
+import { LogLevel, getLogger, parseLogLevel } from "@prosopo/common";
+import { loadEnv, getEnv } from "@prosopo/dotenv";
+import { encodeProcaptchaOutput, decodeProcaptchaOutput } from "@prosopo/types";
+import { getScriptsPkgDir } from "@prosopo/workspace";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { importContract } from "../contract/index.js";
+import "../contract/index.js";
 import setVersion from "../scripts/setVersion.js";
-import { setup } from "../setup/index.js";
-import { exec } from "../util/index.js";
+import "../setup/index.js";
+import "../util/index.js";
+import { exec } from "../util/exec.js";
+import { setup } from "../setup/setup.js";
+import importContract from "../contract/import.js";
 const rootDir = path.resolve(".");
 loadEnv(rootDir);
-export async function processArgs(args) {
-    const parsed = await yargs(hideBin(args)).option("logLevel", {
-        describe: "set log level",
-        choices: Object.keys(LogLevel.enum),
-    }).argv;
-    const log = getLogger(parseLogLevel(parsed.logLevel), "CLI");
-    await yargs(hideBin(args))
-        .usage("Usage: $0 [global options] <command> [options]")
-        .command("create_env_files", "Copies the env.xyz files to .env.xyz", (yargs) => yargs, async () => {
-        const env = getEnv();
-        const scripts = getScriptsPkgDir();
-        await exec(`cp -v ${scripts}/env.${env} ${scripts}/.env.${env}`);
-    }, [])
-        .command({
-        command: "setup",
-        describe: "Setup the development environment by registering a provider, staking, loading a data set and then registering a dapp and staking.",
-        builder: (yargs) => yargs
-            .option("sites", {
-            type: "boolean",
-            demandOption: false,
-            default: true,
-            desc: "Set up sites",
-        })
-            .option("provider", {
-            type: "boolean",
-            demandOption: false,
-            default: true,
-            desc: "Set up the provider",
-        }),
-        handler: async (argv) => {
-            log.info(() => ({ msg: "Running setup scripts" }));
-            await setup(argv.provider, argv.sites);
-        },
-    })
-        .command({
-        command: "import_contract",
-        describe: "Import a contract into the contract package.",
-        builder: (yargs) => yargs
-            .option("in", {
-            type: "string",
-            demandOption: true,
-            desc: "The path to the contract's abi",
-        })
-            .option("out", {
-            type: "string",
-            demandOption: true,
-            desc: "The path to the output directory",
-        }),
-        handler: async (argv) => {
-            await importContract(argv.in, argv.out);
-        },
-    })
-        .command({
-        command: "version",
-        describe: "Set the version of packages",
-        builder: (yargs) => yargs.option("v", { type: "string", demandOption: true }),
-        handler: async (argv) => {
-            await setVersion(String(argv.v));
-        },
-    })
-        .command({
-        command: "token <token>",
-        describe: "Encode or Decode a Procaptcha token to the JSON output format",
-        builder: (yargs) => yargs.positional("token", {
-            describe: "a Procaptcha token to decode",
-            type: "string",
-            demandOption: true,
-        }),
-        handler: async (argv) => {
-            if (!isHex(argv.token)) {
-                log.debug(() => ({ msg: "Encoding token to hex" }));
-                log.info(() => ({
-                    data: { result: encodeProcaptchaOutput(JSON.parse(argv.token)) },
-                }));
-            }
-            else {
-                log.debug(() => ({ msg: "Decoding token from hex" }));
-                log.info(() => ({
-                    data: { result: decodeProcaptchaOutput(argv.token) },
-                }));
-            }
-        },
-    }).argv;
+async function processArgs(args) {
+  const parsed = await yargs(hideBin(args)).option("logLevel", {
+    describe: "set log level",
+    choices: Object.keys(LogLevel.enum)
+  }).argv;
+  const log = getLogger(parseLogLevel(parsed.logLevel), "CLI");
+  await yargs(hideBin(args)).usage("Usage: $0 [global options] <command> [options]").command(
+    "create_env_files",
+    "Copies the env.xyz files to .env.xyz",
+    (yargs2) => yargs2,
+    async () => {
+      const env = getEnv();
+      const scripts = getScriptsPkgDir();
+      await exec(`cp -v ${scripts}/env.${env} ${scripts}/.env.${env}`);
+    },
+    []
+  ).command({
+    command: "setup",
+    describe: "Setup the development environment by registering a provider, staking, loading a data set and then registering a dapp and staking.",
+    builder: (yargs2) => yargs2.option("sites", {
+      type: "boolean",
+      demandOption: false,
+      default: true,
+      desc: "Set up sites"
+    }).option("provider", {
+      type: "boolean",
+      demandOption: false,
+      default: true,
+      desc: "Set up the provider"
+    }),
+    handler: async (argv) => {
+      log.info(() => ({ msg: "Running setup scripts" }));
+      await setup(argv.provider, argv.sites);
+    }
+  }).command({
+    command: "import_contract",
+    describe: "Import a contract into the contract package.",
+    builder: (yargs2) => yargs2.option("in", {
+      type: "string",
+      demandOption: true,
+      desc: "The path to the contract's abi"
+    }).option("out", {
+      type: "string",
+      demandOption: true,
+      desc: "The path to the output directory"
+    }),
+    handler: async (argv) => {
+      await importContract(argv.in, argv.out);
+    }
+  }).command({
+    command: "version",
+    describe: "Set the version of packages",
+    builder: (yargs2) => yargs2.option("v", { type: "string", demandOption: true }),
+    handler: async (argv) => {
+      await setVersion(String(argv.v));
+    }
+  }).command({
+    command: "token <token>",
+    describe: "Encode or Decode a Procaptcha token to the JSON output format",
+    builder: (yargs2) => yargs2.positional("token", {
+      describe: "a Procaptcha token to decode",
+      type: "string",
+      demandOption: true
+    }),
+    handler: async (argv) => {
+      if (!isHex(argv.token)) {
+        log.debug(() => ({ msg: "Encoding token to hex" }));
+        log.info(() => ({
+          data: { result: encodeProcaptchaOutput(JSON.parse(argv.token)) }
+        }));
+      } else {
+        log.debug(() => ({ msg: "Decoding token from hex" }));
+        log.info(() => ({
+          data: { result: decodeProcaptchaOutput(argv.token) }
+        }));
+      }
+    }
+  }).argv;
 }
-processArgs(process.argv)
-    .then(() => {
-    process.exit(0);
-})
-    .catch((error) => {
-    console.error(error);
-    process.exit(1);
+processArgs(process.argv).then(() => {
+  process.exit(0);
+}).catch((error) => {
+  console.error(error);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map
+export {
+  processArgs
+};