@taqueria/plugin-archetype/index.js

A taqueria plugin for compiling Archetype smart contracts

"use strict";

// index.ts
var import_node_sdk3 = require("@taqueria/node-sdk");

// compile.ts
var import_node_sdk = require("@taqueria/node-sdk");
var import_path = require("path");
var import_ts_pattern = require("ts-pattern");
var ARCHETYPE_DEFAULT_IMAGE = "completium/archetype:1.5.2";
var ARCHETYPE_IMAGE_ENV_VAR = "TAQ_ARCHETYPE_IMAGE";
var getArchetypeDockerImage = () => (0, import_node_sdk.getDockerImage)(ARCHETYPE_DEFAULT_IMAGE, ARCHETYPE_IMAGE_ENV_VAR);
var getInputFilename = (opts) => (sourceFile) => {
  const inputFile = (0, import_path.basename)(sourceFile, (0, import_path.extname)(sourceFile));
  return (0, import_path.join)(opts.config.contractsDir ?? "contracts", `${inputFile}.arl`);
};
var getContractArtifactFilename = (opts) => (sourceFile) => {
  const outFile = (0, import_path.basename)(sourceFile, (0, import_path.extname)(sourceFile));
  return (0, import_path.join)(opts.config.artifactsDir ?? "contracts", `${outFile}.tz`);
};
var getCompileCommand = (opts) => (sourceFile) => {
  const { projectDir } = opts;
  const inputFile = getInputFilename(opts)(sourceFile);
  const baseCommand = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -u $(id -u):$(id -g) -w /project ${getArchetypeDockerImage()} ${inputFile}`;
  const outFile = `-o ${getContractArtifactFilename(opts)(sourceFile)}`;
  const cmd = `${baseCommand} ${outFile}`;
  return cmd;
};
var compileContract = (opts) => (sourceFile) => (
  // const sourceAbspath = join(opts.contractsDir, sourceFile)
  (0, import_node_sdk.execCmd)(getCompileCommand(opts)(sourceFile)).then(({ stderr }) => {
    if (stderr.length > 0) (0, import_node_sdk.sendErr)(stderr);
    return {
      contract: sourceFile,
      artifact: getContractArtifactFilename(opts)(sourceFile)
    };
  }).catch((err) => {
    (0, import_node_sdk.sendErr)(" ");
    (0, import_node_sdk.sendErr)(err.message.split("\n").slice(1).join("\n"));
    return Promise.resolve({
      contract: sourceFile,
      artifact: "Not compiled"
    });
  })
);
var compileAll = (opts) => {
  const contracts = (0, import_node_sdk.getContracts)(/\.arl$/, opts.config);
  return Promise.all(contracts).then((entries) => entries.map(compileContract(opts))).then(
    (processes) => processes.length > 0 ? processes : [{ contract: "None found", artifact: "N/A" }]
  ).then((promises) => Promise.all(promises));
};
var compile = (parsedArgs) => {
  const unsafeOpts = parsedArgs;
  return (0, import_ts_pattern.match)(unsafeOpts).when((unsafeOpts2) => unsafeOpts2.task === "get-image", () => (0, import_node_sdk.sendAsyncRes)(getArchetypeDockerImage())).otherwise(() => {
    const p = unsafeOpts.sourceFile ? compileContract(unsafeOpts)(unsafeOpts.sourceFile).then((result) => [result]) : compileAll(unsafeOpts).then((results) => {
      if (results.length === 0) (0, import_node_sdk.sendErr)("No contracts found to compile.");
      return results;
    });
    return p.then(import_node_sdk.sendJsonRes).catch((err) => (0, import_node_sdk.sendAsyncErr)(err, false));
  });
};
var compile_default = compile;

// createContract.ts
var import_node_sdk2 = require("@taqueria/node-sdk");
var import_promises = require("fs/promises");

// archetype_template.ts
var arl_template = `
archetype hello

variable msg : string = "Hello"

entry input(name : string) {
  msg += " " + name
}
`;

// createContract.ts
var validateExtension = async (contractName) => {
  const matchResult = contractName.match(/\.arl$/);
  if (matchResult) return;
  return (0, import_node_sdk2.sendAsyncErr)(`"${contractName}" doesn't have extension "arl".`);
};
var createContract = (args) => {
  const contractName = args.sourceFileName;
  const contractsDir = `${args.config.projectDir}/${args.config.contractsDir}`;
  return validateExtension(contractName).then((_) => (0, import_promises.writeFile)(`${contractsDir}/${contractName}`, arl_template));
};
var createContract_default = createContract;

// index.ts
import_node_sdk3.Plugin.create((i18n) => ({
  schema: "1.0",
  version: "0.1",
  alias: "archetype",
  tasks: [
    import_node_sdk3.Task.create({
      task: "compile",
      command: "compile [sourceFile]",
      aliases: ["c", "compile-archetype"],
      description: "Compile a smart contract written in a Archetype syntax to Michelson code",
      options: [],
      handler: "proxy",
      encoding: "json"
    }),
    import_node_sdk3.Task.create({
      task: "decompile",
      command: "decompile [sourceFile]",
      aliases: ["d", "decompile-archetype"],
      description: "Decompile a Michelson smart contract to Archetype source code",
      options: [],
      handler: "proxy",
      encoding: "json"
    }),
    import_node_sdk3.Task.create({
      task: "get-image",
      command: "get-image",
      description: "Gets the name of the image to be used",
      handler: "proxy",
      hidden: true
    })
  ],
  templates: [
    import_node_sdk3.Template.create({
      template: "archetypeContract",
      command: "archetypeContract <sourceFileName>",
      description: "Create a Archetype contract with boilerplate code",
      positionals: [
        import_node_sdk3.PositionalArg.create({
          placeholder: "sourceFileName",
          type: "string",
          description: "The name of the Archetype contract to generate"
        })
      ],
      handler: createContract_default
    })
  ],
  proxy: compile_default
}), process.argv);
//# sourceMappingURL=index.js.map