@magek/cli 0.0.1

package/dist/common/script.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Script = void 0;
+const tslib_1 = require("tslib");
+const ReaderTaskEither_js_1 = require("fp-ts/lib/ReaderTaskEither.js");
+const pipeable_js_1 = require("fp-ts/lib/pipeable.js");
+const Either_js_1 = require("fp-ts/lib/Either.js");
+const TaskEither_js_1 = require("fp-ts/lib/TaskEither.js");
+const function_js_1 = require("fp-ts/lib/function.js");
+const logger_js_1 = require("../services/logger.js");
+const brand_js_1 = tslib_1.__importDefault(require("./brand.js"));
+/**
+ * A Script represents some steps in a Magek command, it stores the initial context
+ * implicitly, and makes it available for all of the steps that define this process.
+ */
+class Script {
+    constructor(contextResolver, errorHandlers, action) {
+        /**
+         * Method that eases the creation of steps. It accepts a message to be shown in the spinner and a
+         * function that receives the context and the input from the previous step.
+         * From this function you must return a Promise that resolves with the value that you want to pass to the next step (if any)
+         *
+         * @param message Message to initialize the spinner
+         * @param action Function that receives the config object and performs an action
+         */
+        this.step = (message, action) => new Script(this.contextResolver, this.errorHandlers, (0, pipeable_js_1.pipe)(this.action, (0, ReaderTaskEither_js_1.chain)(() => (0, ReaderTaskEither_js_1.ask)()), (0, ReaderTaskEither_js_1.chain)((ctx) => (0, ReaderTaskEither_js_1.fromTaskEither)((0, TaskEither_js_1.tryCatch)(async () => {
+            Script.logger.start(message);
+            await action(ctx);
+            Script.logger.succeed(message);
+        }, (err) => {
+            Script.logger.fail(message);
+            return err;
+        })))));
+        /**
+         * Function to determine next action depending on passed boolean condition
+         * If condition is true, step will be skipped and info action will be called.
+         * Otherwise, step method will be called as usual.
+         *
+         * @param skipCondition When true, the action is skipped
+         * @param message Message to initialize the spinner
+         * @param action Function that receives the config object and performs an action
+         */
+        this.optionalStep = (skipCondition, message, action) => {
+            if (skipCondition)
+                return this.info(brand_js_1.default.mellancholize(`Skipping: ${message}`));
+            return this.step(message, action);
+        };
+        /**
+         * Convenience method to generate a step that just prints a message with a small blue `i` character in front of it.
+         *
+         * @param message Message to be shown in the CLI
+         */
+        this.info = (message) => new Script(this.contextResolver, this.errorHandlers, (0, pipeable_js_1.pipe)(this.action, (0, ReaderTaskEither_js_1.chain)(() => (0, ReaderTaskEither_js_1.rightIO)(() => {
+            Script.logger.info(message);
+        }))));
+        /**
+         * Add a handler to catch a specific type of errors
+         *
+         * @param errorType the kind of errors that the handler will catch
+         * @param handler handler for the errors
+         */
+        this.catch = (errorType, handler) => {
+            const newHandlers = { ...this.errorHandlers };
+            newHandlers[errorType] = handler;
+            return new Script(this.contextResolver, newHandlers, this.action);
+        };
+        this.contextResolver = contextResolver;
+        this.errorHandlers = errorHandlers;
+        this.action = action;
+    }
+    /**
+     * Function to finish the script,
+     * it will handle any error in between that might happen in
+     * some steps.
+     */
+    async done() {
+        try {
+            const context = await this.contextResolver;
+            const result = await this.action(context)();
+            return (0, pipeable_js_1.pipe)(result, (0, Either_js_1.fold)((err) => {
+                throw err;
+            }, function_js_1.constVoid));
+        }
+        catch (err) {
+            const error = err;
+            const defaultHandler = (e) => e.stack || e.message || JSON.stringify(e);
+            const handler = this.errorHandlers[error.name] || defaultHandler;
+            throw new Error(handler(error));
+        }
+    }
+}
+exports.Script = Script;
+/**
+ * Convenience function to print a welcome message and initialize the context of the script
+ *
+ * @param initialMessage The message to show in the console
+ * @param contextResolver A promise that fulfills into a valid context object
+ */
+Script.init = (initialMessage, contextResolver) => new Script(contextResolver, {}, (0, ReaderTaskEither_js_1.rightIO)(() => {
+    Script.logger.info(initialMessage);
+}));
+Script.logger = logger_js_1.oraLogger;

package/dist/hooks/command_not_found/custom-parse.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = require("path");
+const process = tslib_1.__importStar(require("process"));
+const logger_js_1 = require("../../services/logger.js");
+const environment_js_1 = require("../../services/environment.js");
+// Function to find and remove the `-e` argument and its accompanying value
+const extractEnvironmentArg = () => {
+    const argv = process.argv;
+    const eIndex = argv.indexOf('-e'); // Find the index of `-e` in argv
+    let environment; // Variable to store the value found after `-e`
+    if (eIndex !== -1 && eIndex + 1 < argv.length) {
+        environment = argv[eIndex + 1]; // Save the value following `-e`
+        argv.splice(eIndex, 2); // Remove both `-e` and its value from argv
+    }
+    return environment;
+};
+const hook = async function (opts) {
+    var _a;
+    // ensure opts.argv is argv without the environment
+    process.env['MAGEK_CLI_HOOK'] = 'true';
+    if (opts.id === '-e') {
+        opts.id = '';
+        opts.argv = ['-e', ...((_a = opts.argv) !== null && _a !== void 0 ? _a : [])];
+    }
+    const firstArgs = process.argv.filter((arg) => { var _a; return !((_a = opts.argv) === null || _a === void 0 ? void 0 : _a.includes(arg)); });
+    const environment = extractEnvironmentArg();
+    opts.argv = process.argv.filter((arg) => !firstArgs.includes(arg));
+    const cwd = process.cwd();
+    if ((0, environment_js_1.initializeEnvironment)(logger_js_1.logger, environment)) {
+        // to allow doing `magek -e <env>` and show the help
+        if (!opts.id && opts.argv.length === 0) {
+            ;
+            process.argv = [...firstArgs, '--help'];
+        }
+        await import(path.join(cwd, 'dist', 'index.js'));
+    }
+};
+exports.default = hook;

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/dist/services/config-service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanProject = exports.compileProject = exports.compileProjectAndLoadConfig = exports.configService = exports.configServiceDependencies = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const errors_js_1 = require("../common/errors.js");
+const project_checker_js_1 = require("./project-checker.js");
+const environment_js_1 = require("./environment.js");
+const live_impl_js_1 = require("./package-manager/live.impl.js");
+const loadUserProject = (userProjectPath) => {
+    const projectIndexJSPath = path.resolve(path.join(userProjectPath, 'dist', 'index.js'));
+    return require(projectIndexJSPath);
+};
+exports.configServiceDependencies = {
+    loadUserProject,
+    checkItIsAMagekProject: project_checker_js_1.checkItIsAMagekProject,
+    currentEnvironment: environment_js_1.currentEnvironment,
+};
+const compileProjectAndLoadConfigImpl = async (userProjectPath) => {
+    await exports.configServiceDependencies.checkItIsAMagekProject(userProjectPath);
+    await exports.configService.compileProject(userProjectPath);
+    return readProjectConfig(userProjectPath);
+};
+const compileProjectImpl = async (projectPath) => {
+    try {
+        const packageManager = await (0, live_impl_js_1.createLivePackageManager)();
+        packageManager.setProjectRoot(projectPath);
+        await cleanProjectImpl(projectPath);
+        await packageManager.build([]);
+    }
+    catch (error) {
+        throw (0, errors_js_1.guardError)('Project contains compilation errors')(error);
+    }
+};
+const cleanProjectImpl = async (projectPath) => {
+    try {
+        const packageManager = await (0, live_impl_js_1.createLivePackageManager)();
+        packageManager.setProjectRoot(projectPath);
+        await packageManager.runScript('clean', []);
+    }
+    catch (error) {
+        throw (0, errors_js_1.guardError)('Could not clean project')(error);
+    }
+};
+function readProjectConfig(userProjectPath) {
+    const userProject = exports.configServiceDependencies.loadUserProject(userProjectPath);
+    return new Promise((resolve) => {
+        userProject.Magek.configureCurrentEnv((config) => {
+            checkEnvironmentWasConfigured(userProject);
+            resolve(config);
+        });
+    });
+}
+function checkEnvironmentWasConfigured(userProject) {
+    if (userProject.Magek.configuredEnvironments.size == 0) {
+        throw new Error("You haven't configured any environment. Please make sure you have at least one environment configured by calling 'Magek.configure' method (normally done inside the folder 'src/config')");
+    }
+    const currentEnv = exports.configServiceDependencies.currentEnvironment();
+    if (!currentEnv) {
+        throw new Error("You haven't provided any environment. Please make sure you are using option '-e' with a valid environment name");
+    }
+    if (!userProject.Magek.configuredEnvironments.has(currentEnv)) {
+        throw new Error(`The environment '${currentEnv}' does not match any of the environments you used to configure your Magek project, which are: '${Array.from(userProject.Magek.configuredEnvironments).join(', ')}'`);
+    }
+}
+exports.configService = {
+    compileProjectAndLoadConfig: compileProjectAndLoadConfigImpl,
+    compileProject: compileProjectImpl,
+    cleanProject: cleanProjectImpl,
+};
+const compileProjectAndLoadConfig = (...args) => exports.configService.compileProjectAndLoadConfig(...args);
+exports.compileProjectAndLoadConfig = compileProjectAndLoadConfig;
+const compileProject = (...args) => exports.configService.compileProject(...args);
+exports.compileProject = compileProject;
+const cleanProject = (...args) => exports.configService.cleanProject(...args);
+exports.cleanProject = cleanProject;

package/dist/services/environment.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentEnvironment = exports.initializeEnvironment = exports.environmentService = void 0;
+const initializeEnvironmentImpl = (logger, environment) => {
+    if (environment) {
+        process.env.MAGEK_ENV = environment;
+    }
+    if (!exports.environmentService.currentEnvironment()) {
+        logger.error('Error: No environment set. Use the flag `-e` or set the environment variable MAGEK_ENV to set it before running this command. Example usage: `magek start -e <environment>`.');
+        return false;
+    }
+    return true;
+};
+const currentEnvironmentImpl = () => process.env.MAGEK_ENV;
+exports.environmentService = {
+    initializeEnvironment: initializeEnvironmentImpl,
+    currentEnvironment: currentEnvironmentImpl,
+};
+const initializeEnvironment = (...args) => exports.environmentService.initializeEnvironment(...args);
+exports.initializeEnvironment = initializeEnvironment;
+const currentEnvironment = (...args) => exports.environmentService.currentEnvironment(...args);
+exports.currentEnvironment = currentEnvironment;

package/dist/services/file-system/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemError = void 0;
+class FileSystemError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this._tag = 'FileSystemError';
+        this.name = 'FileSystemError';
+    }
+}
+exports.FileSystemError = FileSystemError;

package/dist/services/file-system/live.impl.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liveFileSystemService = exports.createFileSystemService = void 0;
+const tslib_1 = require("tslib");
+const index_js_1 = require("./index.js");
+const fs = tslib_1.__importStar(require("fs"));
+const createFileSystemService = () => ({
+    readDirectoryContents: async (directoryPath) => {
+        try {
+            return await fs.promises.readdir(directoryPath);
+        }
+        catch (reason) {
+            throw new index_js_1.FileSystemError(`There were some issues reading the directory ${directoryPath}`, reason instanceof Error ? reason : new Error(String(reason)));
+        }
+    },
+    readFileContents: async (filePath) => {
+        try {
+            return await fs.promises.readFile(filePath, 'utf8');
+        }
+        catch (reason) {
+            throw new index_js_1.FileSystemError(`There were some issues reading the file ${filePath}`, reason instanceof Error ? reason : new Error(String(reason)));
+        }
+    },
+});
+exports.createFileSystemService = createFileSystemService;
+exports.liveFileSystemService = (0, exports.createFileSystemService)();

package/dist/services/generator/target/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./parsing.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/dist/services/generator/target/parsing.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReaction = exports.parseProjectionField = exports.parseProjections = exports.parseFields = exports.parseEvent = exports.parseName = void 0;
+exports.joinParsers = joinParsers;
+const parseName = (name) => Promise.resolve({ name });
+exports.parseName = parseName;
+const parseEvent = (event) => Promise.resolve({ event });
+exports.parseEvent = parseEvent;
+const parseFields = async (fields) => {
+    const parsedFields = await Promise.all(fields.map(parseField));
+    const parsedFieldNames = parsedFields.map((field) => field.name);
+    const uniqueFieldNames = new Set(parsedFieldNames);
+    const duplicates = parsedFieldNames.filter((field) => !uniqueFieldNames.delete(field));
+    if (duplicates.length > 0) {
+        throw fieldDuplicatedError(duplicates.join(', '));
+    }
+    return { fields: parsedFields };
+};
+exports.parseFields = parseFields;
+function parseField(rawField) {
+    const splitInput = rawField.split(':');
+    if (splitInput.length != 2 || splitInput[0].length === 0 || splitInput[1].length === 0) {
+        return Promise.reject(fieldParsingError(rawField));
+    }
+    else {
+        return Promise.resolve({
+            name: splitInput[0],
+            type: splitInput[1],
+        });
+    }
+}
+const parseProjections = (fields) => Promise.all(fields.map(parseProjection)).then((projections) => ({ projections }));
+exports.parseProjections = parseProjections;
+const parseProjectionField = (field) => parseProjection(field).then((projection) => ({ projection }));
+exports.parseProjectionField = parseProjectionField;
+async function parseProjection(rawProjection) {
+    const splitInput = rawProjection.split(':');
+    if (splitInput.length != 2 || splitInput[0].length === 0 || splitInput[1].length === 0) {
+        throw projectionParsingError(rawProjection);
+    }
+    else {
+        return {
+            entityName: splitInput[0],
+            entityId: splitInput[1],
+        };
+    }
+}
+const parseReaction = (rawEvents) => Promise.all(rawEvents.map(parseReactionEvent)).then((events) => ({
+    events,
+}));
+exports.parseReaction = parseReaction;
+const parseReactionEvent = (eventName) => Promise.resolve({ eventName });
+const fieldParsingError = (field) => new Error(`Error parsing field ${field}. Fields must be in the form of <field name>:<field type>`);
+const fieldDuplicatedError = (field) => new Error(`Error parsing field ${field}. Fields cannot be duplicated`);
+const projectionParsingError = (projection) => new Error(`Error parsing projection ${projection}. Projections must be in the form of <entity name>:<entity id>`);
+function joinParsers(...parsers) {
+    return Promise.all(parsers).then((results) => {
+        let merged = {};
+        for (const value of results) {
+            merged = Object.assign(merged, value);
+        }
+        return merged;
+    });
+}

package/dist/services/generator/target/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/generator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+exports.template = template;
+exports.filePath = filePath;
+exports.getResourceType = getResourceType;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fsExtra = tslib_1.__importStar(require("fs-extra"));
+const Mustache = tslib_1.__importStar(require("mustache"));
+const filenames_js_1 = require("../common/filenames.js");
+const project_checker_js_1 = require("./project-checker.js");
+const stub_publisher_js_1 = require("./stub-publisher.js");
+async function generate(target) {
+    await (0, project_checker_js_1.checkResourceExists)(target.name, target.placementDir, target.extension);
+    (0, filenames_js_1.checkResourceNameIsValid)(target.name);
+    const rendered = Mustache.render(target.template, { ...target.info });
+    const renderPath = filePath(target);
+    await fsExtra.outputFile(renderPath, rendered);
+}
+function template(name) {
+    const fileName = `${name}.stub`;
+    const stubFile = (0, stub_publisher_js_1.resourceStubFilePath)(fileName);
+    if ((0, stub_publisher_js_1.checkStubsFolderExists)() && (0, stub_publisher_js_1.checkResourceStubFileExists)(stubFile)) {
+        return fsExtra.readFileSync(stubFile).toString();
+    }
+    return fsExtra.readFileSync((0, stub_publisher_js_1.resourceTemplateFilePath)(fileName)).toString();
+}
+function filePath(target) {
+    const fileName = (0, filenames_js_1.classNameToFileName)(target.name);
+    return path.join(process.cwd(), target.placementDir, `${fileName}${target.extension}`);
+}
+/**
+ * Split path string to get resource folder name
+ *
+ * @param resourcePath path string
+ */
+function getResourceType(resourcePath) {
+    return path.parse(resourcePath).name;
+}

package/dist/services/logger.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.oraLogger = void 0;
+exports.appendOnErrorsFile = appendOnErrorsFile;
+const tslib_1 = require("tslib");
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+exports.oraLogger = (0, ora_1.default)({ stream: process.stdout });
+exports.logger = {
+    debug: (message) => exports.oraLogger.warn(message),
+    info: (message) => exports.oraLogger.info(message),
+    warn: (message) => exports.oraLogger.warn(message),
+    error: (message) => exports.oraLogger.fail(message),
+};
+function appendOnErrorsFile(data) {
+    const errorsFile = path.join(process.cwd(), 'errors.log');
+    const transformedData = data
+        .split('\n')
+        .map((line) => `[${new Date().toISOString()}] ${line}`)
+        .join('\n');
+    (0, fs_1.appendFileSync)(errorsFile, transformedData);
+}

package/dist/services/method-generator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProjection = exports.generateReducers = exports.getResourceSourceFile = exports.methodGenerator = void 0;
+const ts_morph_1 = require("ts-morph");
+const filenames_js_1 = require("../common/filenames.js");
+const getResourceSourceFileImpl = (name) => {
+    const project = new ts_morph_1.Project({
+        tsConfigFilePath: './tsconfig.json',
+        manipulationSettings: {
+            quoteKind: ts_morph_1.QuoteKind.Single,
+            indentationText: ts_morph_1.IndentationText.TwoSpaces,
+        },
+    });
+    const sourceFileName = (0, filenames_js_1.fileNameWithExtension)(name);
+    return project.getSourceFileOrThrow(sourceFileName);
+};
+const generateReducersImpl = (entity, events) => {
+    return events.map(({ eventName }) => {
+        return {
+            decorators: [
+                {
+                    name: 'Reduces',
+                    arguments: [eventName],
+                },
+            ],
+            scope: ts_morph_1.Scope.Public,
+            isStatic: true,
+            name: `reduce${eventName}`,
+            returnType: entity,
+            parameters: [
+                {
+                    name: 'event',
+                    type: eventName,
+                },
+                {
+                    name: `current${entity}`,
+                    type: entity,
+                    hasQuestionToken: true,
+                },
+            ],
+            statements: [`return /* NEW ${entity} HERE */`],
+        };
+    });
+};
+const generateProjectionImpl = (readModel, projection) => {
+    return {
+        decorators: [
+            {
+                name: 'Projects',
+                arguments: [projection.entityName, `'${projection.entityId}'`],
+            },
+        ],
+        scope: ts_morph_1.Scope.Public,
+        isStatic: true,
+        name: `project${projection.entityName}`,
+        parameters: [
+            {
+                name: 'entity',
+                type: projection.entityName,
+            },
+            {
+                name: `current${readModel}`,
+                type: readModel,
+                hasQuestionToken: true,
+            },
+        ],
+        returnType: `ProjectionResult<${readModel}>`,
+        statements: [`return /* NEW ${readModel} HERE */`],
+    };
+};
+exports.methodGenerator = {
+    getResourceSourceFile: getResourceSourceFileImpl,
+    generateReducers: generateReducersImpl,
+    generateProjection: generateProjectionImpl,
+};
+const getResourceSourceFile = (...args) => exports.methodGenerator.getResourceSourceFile(...args);
+exports.getResourceSourceFile = getResourceSourceFile;
+const generateReducers = (...args) => exports.methodGenerator.generateReducers(...args);
+exports.generateReducers = generateReducers;
+const generateProjection = (...args) => exports.methodGenerator.generateProjection(...args);
+exports.generateProjection = generateProjection;

package/dist/services/package-manager/common.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageManagerService = exports.makeScopedRun = void 0;
+const index_js_1 = require("./index.js");
+/**
+ * Returns a function that executes a package manager command in the project directory.
+ */
+const makeScopedRun = (packageManagerCommand, processService, projectDirRef) => {
+    return async (scriptName, subscriptName, args) => {
+        const projectDir = projectDirRef.value || processService.cwd();
+        if (!projectDirRef.value) {
+            projectDirRef.value = projectDir;
+        }
+        return processService.exec(`${packageManagerCommand} ${scriptName} ${subscriptName ? subscriptName + ' ' : ''}${args.join(' ')}`.trim(), projectDir);
+    };
+};
+exports.makeScopedRun = makeScopedRun;
+/**
+ * Checks if a script exists in the package.json file
+ */
+const checkScriptExists = async (processService, fileSystemService, scriptName) => {
+    const pwd = processService.cwd();
+    const packageJson = await fileSystemService.readFileContents(`${pwd}/package.json`);
+    const packageJsonContents = JSON.parse(packageJson);
+    return !!(packageJsonContents.scripts && packageJsonContents.scripts[scriptName]);
+};
+const createPackageManagerService = (packageManagerCommand, deps) => {
+    const { processService, fileSystemService } = deps;
+    // Create a reference to store the current project directory
+    const projectDirRef = { value: '' };
+    // Create a function to run a script in the project directory
+    const run = (0, exports.makeScopedRun)(packageManagerCommand, processService, projectDirRef);
+    const service = {
+        setProjectRoot: (projectDir) => {
+            projectDirRef.value = projectDir;
+        },
+        runScript: async (scriptName, args) => {
+            try {
+                return await run('run', scriptName, args);
+            }
+            catch (error) {
+                throw new index_js_1.RunScriptError(`Failed to run script ${scriptName}`, error instanceof Error ? error : undefined);
+            }
+        },
+        build: async (args) => {
+            try {
+                const scriptExists = await checkScriptExists(processService, fileSystemService, 'compile');
+                const scriptName = scriptExists ? 'compile' : 'build';
+                return await run('run', scriptName, args);
+            }
+            catch (error) {
+                throw new index_js_1.RunScriptError('Failed to build', error instanceof Error ? error : undefined);
+            }
+        },
+        installProductionDependencies: async () => {
+            try {
+                await run('install', null, ['--omit=dev', '--omit=optional', '--no-bin-links']);
+            }
+            catch (error) {
+                throw new index_js_1.InstallDependenciesError('Failed to install production dependencies', error instanceof Error ? error : undefined);
+            }
+        },
+        installAllDependencies: async () => {
+            try {
+                await run('install', null, []);
+            }
+            catch (error) {
+                throw new index_js_1.InstallDependenciesError('Failed to install dependencies', error instanceof Error ? error : undefined);
+            }
+        },
+    };
+    return service;
+};
+exports.createPackageManagerService = createPackageManagerService;

package/dist/services/package-manager/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunScriptError = exports.InstallDependenciesError = void 0;
+class InstallDependenciesError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this._tag = 'InstallDependenciesError';
+        this.name = 'InstallDependenciesError';
+    }
+}
+exports.InstallDependenciesError = InstallDependenciesError;
+class RunScriptError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this._tag = 'RunScriptError';
+        this.name = 'RunScriptError';
+    }
+}
+exports.RunScriptError = RunScriptError;

package/dist/services/package-manager/live.impl.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLivePackageManager = exports.inferPackageManagerFromDirectoryContents = void 0;
+const rush_impl_js_1 = require("./rush.impl.js");
+const pnpm_impl_js_1 = require("./pnpm.impl.js");
+const yarn_impl_js_1 = require("./yarn.impl.js");
+const npm_impl_js_1 = require("./npm.impl.js");
+const live_impl_js_1 = require("../file-system/live.impl.js");
+const live_impl_js_2 = require("../process/live.impl.js");
+const inferPackageManagerFromDirectoryContents = async (processService, fileSystemService) => {
+    const workingDir = processService.cwd();
+    const contents = await fileSystemService.readDirectoryContents(workingDir);
+    if (contents.includes('.rush')) {
+        return rush_impl_js_1.createRushPackageManager;
+    }
+    if (contents.includes('pnpm-lock.yaml')) {
+        return pnpm_impl_js_1.createPnpmPackageManager;
+    }
+    if (contents.includes('yarn.lock')) {
+        return yarn_impl_js_1.createYarnPackageManager;
+    }
+    if (contents.includes('package-lock.json')) {
+        return npm_impl_js_1.createNpmPackageManager;
+    }
+    // Infer npm by default
+    return npm_impl_js_1.createNpmPackageManager;
+};
+exports.inferPackageManagerFromDirectoryContents = inferPackageManagerFromDirectoryContents;
+const createLivePackageManager = async () => {
+    const processService = live_impl_js_2.liveProcessService;
+    const fileSystemService = live_impl_js_1.liveFileSystemService;
+    const factory = await (0, exports.inferPackageManagerFromDirectoryContents)(processService, fileSystemService);
+    return factory({ processService, fileSystemService });
+};
+exports.createLivePackageManager = createLivePackageManager;

package/dist/services/package-manager/npm.impl.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNpmPackageManager = void 0;
+const common_js_1 = require("./common.js");
+const createNpmPackageManager = (deps) => {
+    return (0, common_js_1.createPackageManagerService)('npm', deps);
+};
+exports.createNpmPackageManager = createNpmPackageManager;

package/dist/services/package-manager/pnpm.impl.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPnpmPackageManager = void 0;
+const common_js_1 = require("./common.js");
+const createPnpmPackageManager = (deps) => {
+    return (0, common_js_1.createPackageManagerService)('pnpm', deps);
+};
+exports.createPnpmPackageManager = createPnpmPackageManager;