@taqueria/lib-ligo 0.44.0 → 0.44.2

package/index.mjs

@@ -83,12 +83,19 @@ import { sendAsyncErr as sendAsyncErr5, sendAsyncRes } from "@taqueria/node-sdk"
 
 // common.ts
 import { getDockerImage, sendErr } from "@taqueria/node-sdk";
-import { join } from "path";
-var getInputFilenameAbsPath = (parsedArgs, sourceFile) => join(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts", sourceFile);
+import * as fs from "fs";
+import { delimiter, join } from "path";
+var getInputFilenameAbsPath = (parsedArgs, sourceFile) => join(
+  parsedArgs.config.projectDir,
+  parsedArgs.config.contractsDir ?? "contracts",
+  sourceFile
+);
 var getInputFilenameRelPath = (parsedArgs, sourceFile) => join(parsedArgs.config.contractsDir ?? "contracts", sourceFile);
 var formatLigoError = (err) => {
   let result = err.message.replace(/Command failed.+?\n/, "");
-  if (result.includes("An internal error ocurred. Please, contact the developers.") && result.includes("Module Contract not found with last Contract.")) {
+  if (result.includes(
+    "An internal error ocurred. Please, contact the developers."
+  ) && result.includes("Module Contract not found with last Contract.")) {
     result = `By convention, Taqueria expects you to import your contract with Contract as the module name.
 For instance, if you have a contract in a file called "increment.mligo", in your parameter/storage list file you must include #import "Increment.mligo" "Contract" for compilation to be successful.`;
   } else {
@@ -117,11 +124,42 @@ var emitExternalError = (errs, sourceFile) => {
   });
   sendErr(`===`);
 };
-var configure = (dockerImage, dockerImageEnvVar) => ({
+var configure = (dockerImage, dockerImageEnvVar, canUseLIGOBinary) => ({
   LIGO_DEFAULT_IMAGE: dockerImage,
   LIGO_IMAGE_ENV_VAR: dockerImageEnvVar,
-  getLigoDockerImage: () => getDockerImage(dockerImage, dockerImageEnvVar)
+  getLigoDockerImage: () => getDockerImage(dockerImage, dockerImageEnvVar),
+  baseDriverCmd: (projectDir) => baseDriverCmd(projectDir, dockerImage, canUseLIGOBinary)
 });
+function exists(path) {
+  try {
+    fs.accessSync(path, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getLigoBinaryFromPath() {
+  const { PATH } = process.env;
+  if (!PATH) {
+    return null;
+  }
+  const paths = PATH.split(delimiter);
+  for (const candidatePath of paths) {
+    const possibleLigoPath = join(candidatePath, "ligo");
+    if (exists(possibleLigoPath)) {
+      return possibleLigoPath;
+    }
+  }
+  return null;
+}
+function baseDriverCmd(projectDir, ligoDockerImage, canUseLIGOBinary) {
+  const ligoBinaryFromPath = canUseLIGOBinary ? getLigoBinaryFromPath() : null;
+  if (ligoBinaryFromPath !== null) {
+    return ligoBinaryFromPath;
+  } else {
+    return `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${ligoDockerImage}`;
+  }
+}
 
 // compile.ts
 import {
@@ -142,7 +180,9 @@ var isSupportedLigoSyntax = (sourceFile) => /\.(mligo|jsligo)$/.test(sourceFile)
 var isUnsupportedLigoSyntax = (sourceFile) => /\.(ligo|religo)$/.test(sourceFile);
 var isLIGOFile = (sourceFile) => isSupportedLigoSyntax(sourceFile) || isUnsupportedLigoSyntax(sourceFile);
 var isStorageListFile = (sourceFile) => /.+\.(storageList|storages)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
-var isParameterListFile = (sourceFile) => /.+\.(parameterList|parameters)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
+var isParameterListFile = (sourceFile) => /.+\.(parameterList|parameters)\.(ligo|religo|mligo|jsligo)$/.test(
+  sourceFile
+);
 var extractExt = (path) => {
   const matchResult = path.match(/\.(ligo|religo|mligo|jsligo)$/);
   return matchResult ? matchResult[0] : "";
@@ -226,7 +266,7 @@ var inject = (commonObj) => {
     const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
     if (!projectDir)
       throw new Error(`No project directory provided`);
-    const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} info list-declarations`;
+    const baseCmd = `${commonObj.baseDriverCmd(projectDir)} info list-declarations`;
     const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
     const flags = "--display-format json";
     const cmd = `${baseCmd} ${inputFile} ${flags}`;
@@ -244,27 +284,51 @@ var inject = (commonObj) => {
           const srcFile = removeExt(basename(sourceFile));
           const syntax = extractExt(sourceFile).replace(".", "");
           if (decl === "main") {
-            return [...acc, { moduleName: srcFile, sourceName: sourceFile, sourceFile, type: "file-main", syntax }];
+            return [
+              ...acc,
+              {
+                moduleName: srcFile,
+                sourceName: sourceFile,
+                sourceFile,
+                type: "file-main",
+                syntax
+              }
+            ];
           } else if (decl === "$main") {
-            return [...acc, { moduleName: srcFile, sourceName: sourceFile, sourceFile, type: "file-entry", syntax }];
+            return [
+              ...acc,
+              {
+                moduleName: srcFile,
+                sourceName: sourceFile,
+                sourceFile,
+                type: "file-entry",
+                syntax
+              }
+            ];
           } else if (decl.endsWith(".main")) {
             const moduleName = decl.replace(/\.main$/, "");
-            return [...acc, {
-              moduleName,
-              sourceName: `${sourceFile}/${moduleName}`,
-              sourceFile,
-              type: "module-main",
-              syntax
-            }];
+            return [
+              ...acc,
+              {
+                moduleName,
+                sourceName: `${sourceFile}/${moduleName}`,
+                sourceFile,
+                type: "module-main",
+                syntax
+              }
+            ];
           } else if (decl.endsWith(".$main")) {
             const moduleName = decl.replace(/\.\$main$/, "");
-            return [...acc, {
-              moduleName,
-              sourceName: `${sourceFile}/${moduleName}`,
-              sourceFile,
-              type: "module-entry",
-              syntax
-            }];
+            return [
+              ...acc,
+              {
+                moduleName,
+                sourceName: `${sourceFile}/${moduleName}`,
+                sourceFile,
+                type: "module-entry",
+                syntax
+              }
+            ];
           }
           return acc;
         },
@@ -280,7 +344,7 @@ var inject = (commonObj) => {
     const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
     if (!projectDir)
       throw new Error(`No project directory provided`);
-    const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile contract`;
+    const baseCmd = `${commonObj.baseDriverCmd(projectDir)} compile contract`;
     const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
     const outputFile = `-o ${getOutputContractFilename(parsedArgs, module)}`;
     const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
@@ -312,9 +376,14 @@ var inject = (commonObj) => {
     if (!projectDir)
       throw new Error(`No project directory provided`);
     const compilerType = isStorageKind(exprKind) ? "storage" : "parameter";
-    const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile ${compilerType}`;
+    const baseCmd = `${commonObj.baseDriverCmd(projectDir)} compile ${compilerType}`;
     const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
-    const outputFile = `-o ${getOutputExprFilename(parsedArgs, module, exprKind, exprName)}`;
+    const outputFile = `-o ${getOutputExprFilename(
+      parsedArgs,
+      module,
+      exprKind,
+      exprName
+    )}`;
     const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
     const moduleFlag = (() => {
       switch (module.type) {
@@ -332,7 +401,12 @@ var inject = (commonObj) => {
     return getArch().then(() => getCompileExprCmd(parsedArgs, sourceFile, module, exprKind, exprName)).then(execCmd).then(({ stderr }) => {
       if (stderr.length > 0)
         sendWarn(stderr);
-      const artifactName = getOutputExprFilename(parsedArgs, module, exprKind, exprName);
+      const artifactName = getOutputExprFilename(
+        parsedArgs,
+        module,
+        exprKind,
+        exprName
+      );
       return {
         source: module.sourceName,
         artifact: artifactName
@@ -351,59 +425,85 @@ var inject = (commonObj) => {
       exprs = await getExprNames(parsedArgs, sourceFile);
     } catch (err) {
       emitExternalError(err, sourceFile);
-      return [{
-        source: module.sourceName,
-        artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions compiled`
-      }];
-    }
-    const results = await Promise.all(exprs.map(async (exprName, index) => {
-      const compileResult = await compileExpr(
-        parsedArgs,
-        sourceFile,
-        module,
-        exprKind === "storage" && index === 0 ? "default_storage" : exprKind
-      )(exprName);
-      return compileResult;
-    }));
-    const errors = results.reduce(
-      (acc, result) => {
-        if (result.err) {
-          if (!(result.err instanceof Error))
-            return [...acc, result.err];
-          const ligoErrs = acc.filter((err) => err instanceof Error).map((err) => err.message);
-          const formattedError = formatLigoError(result.err);
-          return ligoErrs.includes(formattedError.message) ? acc : [...acc, formattedError];
+      return [
+        {
+          source: module.sourceName,
+          artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} expressions compiled`
         }
-        return acc;
-      },
-      []
+      ];
+    }
+    const results = await Promise.all(
+      exprs.map(async (exprName, index) => {
+        const compileResult = await compileExpr(
+          parsedArgs,
+          sourceFile,
+          module,
+          exprKind === "storage" && index === 0 ? "default_storage" : exprKind
+        )(exprName);
+        return compileResult;
+      })
     );
-    const retval = results.map(({ source, artifact }) => ({ source, artifact }));
+    const errors = results.reduce((acc, result) => {
+      if (result.err) {
+        if (!(result.err instanceof Error))
+          return [...acc, result.err];
+        const ligoErrs = acc.filter((err) => err instanceof Error).map((err) => err.message);
+        const formattedError = formatLigoError(result.err);
+        return ligoErrs.includes(formattedError.message) ? acc : [...acc, formattedError];
+      }
+      return acc;
+    }, []);
+    const retval = results.map(({ source, artifact }) => ({
+      source,
+      artifact
+    }));
     if (errors.length)
       emitExternalError(errors, sourceFile);
     return retval;
   };
   const compileContractWithStorageAndParameter = async (parsedArgs, sourceFile, module) => {
-    const contractCompileResult = await compileContract(parsedArgs, sourceFile, module);
+    const contractCompileResult = await compileContract(
+      parsedArgs,
+      sourceFile,
+      module
+    );
     if (contractCompileResult.artifact === COMPILE_ERR_MSG)
       return [contractCompileResult];
-    const storageListFile = `${module.moduleName}.storageList${extractExt(sourceFile)}`;
-    const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
+    const storageListFile = `${module.moduleName}.storageList${extractExt(
+      sourceFile
+    )}`;
+    const storageListFilename = getInputFilenameAbsPath(
+      parsedArgs,
+      storageListFile
+    );
     const storageCompileResult = await access(storageListFilename).then(() => compileExprs(parsedArgs, storageListFile, module, "storage")).catch(() => {
       sendWarn(
         `Note: storage file associated with "${module.moduleName}" can't be found, so "${storageListFile}" has been created for you. Use this file to define all initial storage values for this contract
 `
       );
-      return writeFile2(storageListFilename, initContentForStorage(module), "utf8");
+      return writeFile2(
+        storageListFilename,
+        initContentForStorage(module),
+        "utf8"
+      );
     });
-    const parameterListFile = `${module.moduleName}.parameterList${extractExt(sourceFile)}`;
-    const parameterListFilename = getInputFilenameAbsPath(parsedArgs, parameterListFile);
+    const parameterListFile = `${module.moduleName}.parameterList${extractExt(
+      sourceFile
+    )}`;
+    const parameterListFilename = getInputFilenameAbsPath(
+      parsedArgs,
+      parameterListFile
+    );
     const parameterCompileResult = await access(parameterListFilename).then(() => compileExprs(parsedArgs, parameterListFile, module, "parameter")).catch(() => {
       sendWarn(
         `Note: parameter file associated with "${module.moduleName}" can't be found, so "${parameterListFile}" has been created for you. Use this file to define all parameter values for this contract
 `
       );
-      return writeFile2(parameterListFilename, initContentForParameter(module), "utf8");
+      return writeFile2(
+        parameterListFilename,
+        initContentForParameter(module),
+        "utf8"
+      );
     });
     const storageArtifacts = storageCompileResult ? storageCompileResult.map((res) => res.artifact).join("\n") : "";
     const parameterArtifacts = parameterCompileResult ? parameterCompileResult.map((res) => res.artifact).join("\n") : "";
@@ -438,11 +538,15 @@ var compile = async (commonObj, parsedArgs) => {
     return;
   }
   if (isStorageListFile(sourceFile) || isParameterListFile(sourceFile)) {
-    sendErr2(`Storage and parameter list files are not meant to be compiled directly`);
+    sendErr2(
+      `Storage and parameter list files are not meant to be compiled directly`
+    );
     return;
   }
   if (isUnsupportedLigoSyntax(sourceFile)) {
-    sendErr2(`Unsupported LIGO syntax detected in ${sourceFile}. Note, we only support .jsligo and .mligo files.`);
+    sendErr2(
+      `Unsupported LIGO syntax detected in ${sourceFile}. Note, we only support .jsligo and .mligo files.`
+    );
     return;
   }
   try {
@@ -460,11 +564,17 @@ If your contract is defined within a namespace, please ensure that it is exporte
     for (const module of modules) {
       if (parsedArgs.module && parsedArgs.module !== module.moduleName)
         continue;
-      const compileResults = await compileContractWithStorageAndParameter(parsedArgs, sourceFile, module);
+      const compileResults = await compileContractWithStorageAndParameter(
+        parsedArgs,
+        sourceFile,
+        module
+      );
       allCompileResults = allCompileResults.concat(compileResults);
     }
-    sendJsonRes(allCompileResults, { footer: `
-Compiled ${allCompileResults.length} contract(s) in "${sourceFile}"` });
+    sendJsonRes(allCompileResults, {
+      footer: `
+Compiled ${allCompileResults.length} contract(s) in "${sourceFile}"`
+    });
   } catch (err) {
     sendErr2(`Error processing "${sourceFile}": ${err}`);
   }
@@ -498,41 +608,22 @@ var compileAll = async (commonObj, parsedArgs) => {
 var compile_all_default = compileAll;
 
 // ligo.ts
-import { execCmd as execCmd2, sendAsyncErr as sendAsyncErr3, sendRes as sendRes2, spawnCmd } from "@taqueria/node-sdk";
-var getArbitraryLigoCmd = (commonObj, parsedArgs, uid, gid, userArgs) => {
+import { sendAsyncErr as sendAsyncErr3, sendRes as sendRes2, spawnCmd } from "@taqueria/node-sdk";
+var getArbitraryLigoCmd = (commonObj, parsedArgs, userArgs) => {
   const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
   if (!projectDir)
     throw `No project directory provided`;
-  const userMap = uid && gid ? `${uid}:${gid}` : uid;
-  const userMapArgs = uid ? ["-u", userMap] : [];
-  const binary = "docker";
-  const baseArgs = [
-    "run",
-    "--rm",
-    "-v",
-    `${projectDir}:/project`,
-    "-w",
-    "/project",
-    ...userMapArgs,
-    commonObj.getLigoDockerImage()
-  ];
-  const processedUserArgs = userArgs.split(" ").map((arg) => arg.startsWith("\\-") ? arg.substring(1) : arg).filter(
-    (arg) => arg
-  );
-  const args = [...baseArgs, ...processedUserArgs, "--skip-analytics"];
-  const envVars = { "DOCKER_DEFAULT_PLATFORM": "linux/amd64" };
-  return [
-    [binary, ...args].join(" "),
-    envVars
-  ];
+  const processedUserArgs = userArgs.split(" ").map((arg) => arg.startsWith("\\-") ? arg.substring(1) : arg).filter((arg) => arg);
+  const cmd = `${commonObj.baseDriverCmd(projectDir)} ${processedUserArgs.join(" ")}`;
+  const envVars = { DOCKER_DEFAULT_PLATFORM: "linux/amd64" };
+  return [cmd, envVars];
+};
+var runArbitraryLigoCmd = (commonObj, parsedArgs, userCmd) => {
+  let [cmd, envVars] = getArbitraryLigoCmd(commonObj, parsedArgs, userCmd);
+  return spawnCmd(cmd, envVars).then(
+    (code) => code !== null && code === 0 ? `Command "${cmd}" ran successfully by LIGO` : `Command "${cmd}" failed. Please check your command`
+  ).catch((err) => sendAsyncErr3(`An internal error has occurred: ${err.message}`));
 };
-var runArbitraryLigoCmd = (commonObj, parsedArgs, cmd) => (async () => {
-  const uid = await execCmd2("id -u");
-  const gid = await execCmd2("id -g");
-  return [uid.stdout.trim(), gid.stdout.trim()];
-})().then(([uid, gid]) => getArbitraryLigoCmd(commonObj, parsedArgs, uid, gid, cmd)).then(([cmd2, envVars]) => spawnCmd(cmd2, envVars)).then(
-  (code) => code !== null && code === 0 ? `Command "${cmd}" ran successfully by LIGO` : `Command "${cmd}" failed. Please check your command`
-).catch((err) => sendAsyncErr3(`An internal error has occurred: ${err.message}`));
 var ligo = (commonObj, parsedArgs) => {
   const args = parsedArgs.command;
   return runArbitraryLigoCmd(commonObj, parsedArgs, args).then(sendRes2).catch((err) => sendAsyncErr3(err, false));
@@ -540,19 +631,19 @@ var ligo = (commonObj, parsedArgs) => {
 var ligo_default = ligo;
 
 // test.ts
-import { execCmd as execCmd3, getArch as getArch3, sendAsyncErr as sendAsyncErr4, sendJsonRes as sendJsonRes3, sendWarn as sendWarn2 } from "@taqueria/node-sdk";
+import { execCmd as execCmd2, getArch as getArch2, sendAsyncErr as sendAsyncErr4, sendJsonRes as sendJsonRes3, sendWarn as sendWarn2 } from "@taqueria/node-sdk";
 var inject2 = (commonObj) => {
-  const { getLigoDockerImage } = commonObj;
+  const { baseDriverCmd: baseDriverCmd2 } = commonObj;
   const getTestContractCmd = (parsedArgs, sourceFile) => {
     const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
     if (!projectDir)
       throw `No project directory provided`;
-    const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} run test`;
+    const baseCmd = `${baseDriverCmd2(projectDir)} run test`;
     const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
     const cmd = `${baseCmd} ${inputFile}`;
     return cmd;
   };
-  const testContract = (parsedArgs, sourceFile) => getArch3().then(() => getTestContractCmd(parsedArgs, sourceFile)).then(execCmd3).then(({ stdout, stderr }) => {
+  const testContract = (parsedArgs, sourceFile) => getArch2().then(() => getTestContractCmd(parsedArgs, sourceFile)).then(execCmd2).then(({ stdout, stderr }) => {
     if (stderr.length > 0)
       sendWarn2(stderr);
     const result = "\u{1F389} All tests passed \u{1F389}";
@@ -578,15 +669,13 @@ var test = (commonObj, parsedArgs) => {
   const sourceFile = parsedArgs.sourceFile;
   if (!sourceFile)
     return sendAsyncErr4(`No source file provided`);
-  return testContract(parsedArgs, sourceFile).then((result) => [result]).then(sendJsonRes3).catch(
-    (err) => sendAsyncErr4(err, false)
-  );
+  return testContract(parsedArgs, sourceFile).then((result) => [result]).then(sendJsonRes3).catch((err) => sendAsyncErr4(err, false));
 };
 var test_default = test;
 
 // main.ts
-var main = (dockerImage, dockerImageEnvVar) => (parsedArgs) => {
-  const commonObj = configure(dockerImage, dockerImageEnvVar);
+var main = (dockerImage, dockerImageEnvVar, canUseLIGOBinary) => (parsedArgs) => {
+  const commonObj = configure(dockerImage, dockerImageEnvVar, canUseLIGOBinary);
   const unsafeOpts = parsedArgs;
   switch (unsafeOpts.task) {
     case "ligo":
@@ -702,7 +791,7 @@ var configurePlugin = (settings) => {
         handler: createContract_default(settings.templates)
       })
     ],
-    proxy: main_default(settings.dockerImage, settings.dockerImageEnvVar),
+    proxy: main_default(settings.dockerImage, settings.dockerImageEnvVar, settings.canUseLIGOBinary),
     postInstall: `node ${__dirname}/postinstall.js`
   };
   return Plugin.create(() => settings.configurator ? settings.configurator(schema) : schema, settings.unparsedArgs);