@cartesi/cli 2.0.0-alpha.3 → 2.0.0-alpha.31

package/dist/config.js

@@ -1,367 +0,0 @@
-import bytes from "bytes";
-import { extname } from "path";
-import { parse as parseToml } from "smol-toml";
-/**
- * Typed Errors
- */
-export class InvalidBuilderError extends Error {
-    constructor(builder) {
-        super(`Invalid builder: ${builder}`);
-        this.name = "InvalidBuilder";
-    }
-}
-export class InvalidDriveFormatError extends Error {
-    constructor(format) {
-        super(`Invalid drive format: ${format}`);
-        this.name = "InvalidDriveFormatError";
-    }
-}
-export class InvalidEmptyDriveFormatError extends Error {
-    constructor(format) {
-        super(`Invalid empty drive format: ${format}`);
-        this.name = "InvalidEmptyDriveFormatError";
-    }
-}
-export class InvalidStringValueError extends Error {
-    constructor(value) {
-        super(`Invalid string value: ${value}`);
-        this.name = "InvalidStringValueError";
-    }
-}
-export class InvalidBooleanValueError extends Error {
-    constructor(value) {
-        super(`Invalid boolean value: ${value}`);
-        this.name = "InvalidBooleanValueError";
-    }
-}
-export class InvalidNumberValueError extends Error {
-    constructor(value) {
-        super(`Invalid number value: ${value}`);
-        this.name = "InvalidNumberValueError";
-    }
-}
-export class InvalidBytesValueError extends Error {
-    constructor(value) {
-        super(`Invalid bytes value: ${value}`);
-        this.name = "InvalidBytesValueError";
-    }
-}
-export class RequiredFieldError extends Error {
-    constructor(key) {
-        super(`Missing required field: ${key}`);
-        this.name = "RequiredFieldError";
-    }
-}
-export class InvalidStringArrayError extends Error {
-    constructor() {
-        super(`Invalid string array`);
-        this.name = "InvalidStringArrayError";
-    }
-}
-/**
- * Configuration for drives of a Cartesi Machine. A drive may already exist or be built by a builder
- */
-const DEFAULT_FORMAT = "ext2";
-const DEFAULT_RAM = "128Mi";
-const DEFAULT_RAM_IMAGE = "/usr/share/cartesi-machine/images/linux.bin";
-export const DEFAULT_SDK = "cartesi/sdk:0.12.0-alpha.1";
-export const defaultRootDriveConfig = () => ({
-    builder: "docker",
-    context: ".",
-    dockerfile: "Dockerfile", // file on current working directory
-    extraSize: 0,
-    format: DEFAULT_FORMAT,
-    tags: [],
-});
-export const defaultMachineConfig = () => ({
-    assertRollingTemplate: undefined,
-    bootargs: [],
-    entrypoint: undefined,
-    finalHash: true,
-    interactive: undefined,
-    maxMCycle: undefined,
-    noRollup: undefined,
-    ramLength: DEFAULT_RAM,
-    ramImage: DEFAULT_RAM_IMAGE,
-    store: "image",
-    user: undefined,
-});
-export const defaultConfig = () => ({
-    drives: { root: defaultRootDriveConfig() },
-    machine: defaultMachineConfig(),
-    sdk: DEFAULT_SDK,
-});
-const parseBoolean = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    else if (typeof value === "boolean") {
-        return value;
-    }
-    throw new InvalidBooleanValueError(value);
-};
-const parseOptionalBoolean = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    else if (typeof value === "boolean") {
-        return value;
-    }
-    throw new InvalidBooleanValueError(value);
-};
-const parseString = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseStringArray = (value) => {
-    if (value === undefined) {
-        return [];
-    }
-    else if (typeof value === "string") {
-        return [value];
-    }
-    else if (typeof value === "object" && Array.isArray(value)) {
-        return value.map((v) => {
-            if (typeof v === "string") {
-                return v;
-            }
-            throw new InvalidStringValueError(v);
-        });
-    }
-    throw new InvalidStringArrayError();
-};
-const parseRequiredString = (value, key) => {
-    if (value === undefined) {
-        throw new RequiredFieldError(key);
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseOptionalString = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseOptionalStringBoolean = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    else if (typeof value === "boolean") {
-        return value;
-    }
-    throw new InvalidStringValueError(value);
-};
-const parseOptionalNumber = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    else if (typeof value === "bigint") {
-        return value;
-    }
-    else if (typeof value === "number") {
-        return BigInt(value);
-    }
-    throw new InvalidNumberValueError(value);
-};
-const parseBytes = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    else if (typeof value === "bigint") {
-        return Number(value);
-    }
-    else if (typeof value === "number" || typeof value === "string") {
-        const output = bytes.parse(value);
-        if (output !== null) {
-            return output;
-        }
-    }
-    throw new InvalidBytesValueError(value);
-};
-const parseBuilder = (value) => {
-    if (value === undefined) {
-        return "docker";
-    }
-    else if (typeof value === "string") {
-        switch (value) {
-            case "directory":
-                return "directory";
-            case "docker":
-                return "docker";
-            case "empty":
-                return "empty";
-            case "none":
-                return "none";
-            case "tar":
-                return "tar";
-        }
-    }
-    throw new InvalidBuilderError(value);
-};
-const parseFormat = (value) => {
-    if (value === undefined) {
-        return DEFAULT_FORMAT;
-    }
-    else if (typeof value === "string") {
-        switch (value) {
-            case "ext2":
-                return "ext2";
-            case "sqfs":
-                return "sqfs";
-        }
-    }
-    throw new InvalidDriveFormatError(value);
-};
-const parseEmptyFormat = (value) => {
-    if (value === undefined) {
-        return DEFAULT_FORMAT;
-    }
-    else if (typeof value === "string") {
-        switch (value) {
-            case "ext2":
-                return "ext2";
-            case "raw":
-                return "raw";
-        }
-    }
-    throw new InvalidEmptyDriveFormatError(value);
-};
-const parseMachine = (value) => {
-    if (value === undefined) {
-        // default machine
-        return defaultMachineConfig();
-    }
-    if (typeof value !== "object") {
-        throw new Error(`Invalid machine configuration: ${value}`);
-    }
-    const toml = value;
-    return {
-        assertRollingTemplate: parseOptionalBoolean(toml["assert-rolling-template"]),
-        bootargs: parseStringArray(toml.bootargs),
-        finalHash: parseBoolean(toml["final-hash"], true),
-        interactive: undefined,
-        maxMCycle: parseOptionalNumber(toml["max-mcycle"]),
-        noRollup: parseBoolean(toml["no-rollup"], false),
-        ramLength: parseString(toml["ram-length"], DEFAULT_RAM),
-        ramImage: parseString(toml["ram-image"], DEFAULT_RAM_IMAGE),
-        store: "image",
-        user: parseOptionalString(toml.user),
-    };
-};
-export const getDriveFormat = (filename) => {
-    const extension = extname(filename);
-    switch (extension) {
-        case ".ext2":
-            return "ext2";
-        case ".sqfs":
-            return "sqfs";
-        default:
-            throw new InvalidDriveFormatError(extension);
-    }
-};
-const parseDrive = (drive) => {
-    const builder = parseBuilder(drive.builder);
-    switch (builder) {
-        case "directory": {
-            const { extraSize, format, mount, directory, shared, user } = drive;
-            return {
-                builder: "directory",
-                extraSize: parseBytes(extraSize, 0),
-                format: parseFormat(format),
-                mount: parseOptionalStringBoolean(mount),
-                directory: parseRequiredString(directory, "directory"),
-                shared: parseOptionalBoolean(shared),
-                user: parseOptionalString(user),
-            };
-        }
-        case "docker": {
-            const { context, dockerfile, extraSize, format, image, mount, shared, tags, target, user, } = drive;
-            return {
-                builder: "docker",
-                image: parseOptionalString(image),
-                context: parseString(context, "."),
-                dockerfile: parseString(dockerfile, "Dockerfile"),
-                extraSize: parseBytes(extraSize, 0),
-                format: parseFormat(format),
-                mount: parseOptionalStringBoolean(mount),
-                shared: parseOptionalBoolean(shared),
-                user: parseOptionalString(user),
-                tags: parseStringArray(tags),
-                target: parseOptionalString(target),
-            };
-        }
-        case "empty": {
-            const { format, mount, size, shared, user } = drive;
-            return {
-                builder: "empty",
-                format: parseEmptyFormat(format),
-                mount: parseOptionalStringBoolean(mount),
-                shared: parseOptionalBoolean(shared),
-                size: parseBytes(size, 0),
-                user: parseOptionalString(user),
-            };
-        }
-        case "tar": {
-            const { extraSize, filename, format, mount, shared, user } = drive;
-            return {
-                builder: "tar",
-                extraSize: parseBytes(extraSize, 0),
-                filename: parseRequiredString(filename, "filename"),
-                format: parseFormat(format),
-                mount: parseOptionalStringBoolean(mount),
-                shared: parseOptionalBoolean(shared),
-                user: parseOptionalString(user),
-            };
-        }
-        case "none": {
-            const { shared, mount, user } = drive;
-            const filename = parseRequiredString(drive.filename, "filename");
-            const format = getDriveFormat(filename);
-            return {
-                builder: "none",
-                filename,
-                format,
-                mount: parseOptionalStringBoolean(mount),
-                shared: parseOptionalBoolean(shared),
-                user: parseOptionalString(user),
-            };
-        }
-    }
-};
-const parseDrives = (config) => {
-    // load drives from configuration
-    const drives = Object.entries(config ?? {}).reduce((acc, [name, drive]) => {
-        acc[name] = parseDrive(drive);
-        return acc;
-    }, {});
-    // check if there is a root drive
-    const hasRoot = drives.root !== undefined;
-    if (!hasRoot) {
-        // there is no root drive, add a default one
-        drives.root = defaultRootDriveConfig();
-    }
-    return drives;
-};
-export const parse = (str) => {
-    const toml = parseToml(str);
-    const config = {
-        drives: parseDrives(toml.drives),
-        machine: parseMachine(toml.machine),
-        sdk: parseString(toml.sdk, DEFAULT_SDK),
-    };
-    return config;
-};