lincd-cli 1.2.1 → 1.2.3

package/lib/esm/cli-methods.js

@@ -14,18 +14,21 @@ import { getEnvFile } from 'env-cmd/dist/get-env-vars.js';
 import fs from 'fs-extra';
 import path, { dirname } from 'path';
 import { debugInfo, execp, execPromise, getFileImports, getFiles, getLastCommitTime, getPackageJSON, isImportOutsideOfPackage, isImportWithMissingExtension, isInvalidLINCDImport, needsRebuilding, } from './utils.js';
-import { statSync } from 'fs';
+import { spawn as spawnChild } from 'child_process';
 import { findNearestPackageJson } from 'find-nearest-package-json';
+import { statSync } from 'fs';
 import { LinkedFileStorage } from 'lincd/utils/LinkedFileStorage';
 // import pkg from 'lincd/utils/LinkedFileStorage';
 // const { LinkedFileStorage } = pkg;
 // const config = require('lincd-server/site.webpack.config');
 import { glob } from 'glob';
 import webpack from 'webpack';
-import stagedGitFiles from 'staged-git-files';
 import ora from 'ora';
-//@ts-ignore
-let dirname__ = typeof __dirname !== 'undefined' ? __dirname : dirname(import.meta.url).replace('file:/', '');
+import stagedGitFiles from 'staged-git-files';
+let dirname__ = typeof __dirname !== 'undefined'
+    ? __dirname
+    : //@ts-ignore
+        dirname(import.meta.url).replace('file:/', '');
 var variables = {};
 export const createApp = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     if (!name) {
@@ -45,7 +48,7 @@ export const createApp = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...ar
     fs.renameSync(path.join(targetFolder, 'gitignore.template'), path.join(targetFolder, '.gitignore'));
     fs.renameSync(path.join(targetFolder, 'yarnrc.yml.template'), path.join(targetFolder, '.yarnrc.yml'));
     // fs.copySync(path.join(__dirname, '..', 'defaults', 'app'), targetFolder);
-    log('Creating new LINCD application \'' + name + '\'');
+    log("Creating new LINCD application '" + name + "'");
     //replace variables in some copied files
     yield replaceVariablesInFolder(targetFolder);
     let hasYarn = yield hasYarnInstalled();
@@ -71,10 +74,15 @@ function progressUpdate(message) {
 }
 export function warn(...messages) {
     messages.forEach((message) => {
-        console.log(chalk.redBright('Warning: ') + message);
+        console.warn(chalk.redBright('Warning: ') + message);
         // console.log(chalk.red(message));
     });
 }
+export function logError(...messages) {
+    messages.forEach((message) => {
+        console.error(chalk.redBright('Error: ') + message);
+    });
+}
 export function developPackage(target, mode) {
     if (!target)
         target = 'es6';
@@ -140,7 +148,7 @@ function checkPackagePath(rootPath, packagePath, res) {
         }
     }
 }
-function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd, sync = false) {
+export function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd, sync = false) {
     let dependencies = new Map();
     //get dependencies of each package
     let leastDependentPackage;
@@ -308,9 +316,121 @@ function hasDependency(pkg, childPkg, dependencies, depth = 1) {
     console.log('going up');
     return false;
 }
+/**
+ * Finds the topmost package.json that could be an APP_ROOT
+ * Returns null if no app root is found (standalone repo case)
+ */
+function findAppRoot(startPath = process.cwd()) {
+    let currentPath = startPath;
+    let candidateRoots = [];
+    // Walk up the directory tree
+    for (let i = 0; i < 10; i++) {
+        const packageJsonPath = path.join(currentPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            candidateRoots.push({
+                path: currentPath,
+                hasWorkspaces: !!packageJson.workspaces,
+                isLincd: packageJson.lincd === true,
+            });
+        }
+        const parentPath = path.join(currentPath, '..');
+        // If we've reached the root or haven't moved up
+        if (parentPath === currentPath) {
+            break;
+        }
+        currentPath = parentPath;
+    }
+    // Find the topmost package.json that has workspaces
+    // Prefer non-lincd packages (app roots) over lincd packages
+    let appRoot = null;
+    for (let i = candidateRoots.length - 1; i >= 0; i--) {
+        const candidate = candidateRoots[i];
+        if (candidate.hasWorkspaces && !candidate.isLincd) {
+            appRoot = candidate.path;
+            break;
+        }
+    }
+    // If no non-lincd workspace found, use the topmost workspace
+    if (!appRoot) {
+        for (let i = candidateRoots.length - 1; i >= 0; i--) {
+            if (candidateRoots[i].hasWorkspaces) {
+                appRoot = candidateRoots[i].path;
+                break;
+            }
+        }
+    }
+    return appRoot;
+}
+/**
+ * Filters packages to only include those in the dependency tree of the app root
+ */
+function filterPackagesByDependencyTree(allPackages, appRootPath) {
+    const appPackageJson = getPackageJSON(appRootPath);
+    if (!appPackageJson) {
+        return allPackages;
+    }
+    const relevantPackages = new Map();
+    const packagesToCheck = new Set();
+    // Start with direct dependencies from app root
+    if (appPackageJson.dependencies) {
+        Object.keys(appPackageJson.dependencies).forEach((dep) => {
+            if (allPackages.has(dep)) {
+                packagesToCheck.add(dep);
+            }
+        });
+    }
+    // Recursively add dependencies
+    const processedPackages = new Set();
+    while (packagesToCheck.size > 0) {
+        const packageName = Array.from(packagesToCheck)[0];
+        packagesToCheck.delete(packageName);
+        if (processedPackages.has(packageName)) {
+            continue;
+        }
+        processedPackages.add(packageName);
+        const packageDetails = allPackages.get(packageName);
+        if (packageDetails) {
+            relevantPackages.set(packageName, packageDetails);
+            // Get this package's dependencies
+            const packageJson = getPackageJSON(packageDetails.path);
+            if (packageJson && packageJson.dependencies) {
+                Object.keys(packageJson.dependencies).forEach((dep) => {
+                    if (allPackages.has(dep) && !processedPackages.has(dep)) {
+                        packagesToCheck.add(dep);
+                    }
+                });
+            }
+        }
+    }
+    return relevantPackages;
+}
 export function buildAll(options) {
     console.log('Building all LINCD packages of this repository in order of dependencies');
     let lincdPackages = getLocalLincdPackageMap();
+    const originalPackageCount = lincdPackages.size;
+    // Check if we're in an app context and filter packages accordingly
+    const appRoot = findAppRoot();
+    if (appRoot) {
+        const appPackageJson = getPackageJSON(appRoot);
+        // Check if this is an app (not a lincd package itself) with lincd dependencies
+        const isAppWithLincdDeps = appPackageJson &&
+            appPackageJson.lincd !== true &&
+            appPackageJson.dependencies &&
+            Object.keys(appPackageJson.dependencies).some((dep) => lincdPackages.has(dep));
+        if (isAppWithLincdDeps) {
+            debugInfo(chalk.blue(`Found app root at: ${appRoot}`));
+            const filteredPackages = filterPackagesByDependencyTree(lincdPackages, appRoot);
+            console.log(chalk.magenta(`Found ${originalPackageCount} total LINCD packages, building only ${filteredPackages.size} that are relevant to this app`));
+            lincdPackages = filteredPackages;
+        }
+        else {
+            debugInfo(chalk.blue(`Building all ${originalPackageCount} packages from workspace`));
+        }
+    }
+    else {
+        debugInfo(chalk.blue(`No workspace root found, building all ${originalPackageCount} packages`));
+    }
     let startFrom;
     //by default start building
     let building = true;
@@ -384,7 +504,8 @@ export function buildAll(options) {
                 log(chalk.cyan('Building ' + pkg.packageName));
                 process.stdout.write(packagesLeft + ' packages left\r');
             }
-            return command.then(res => {
+            return command
+                .then((res) => {
                 //empty string or true is success
                 //false is success with warnings
                 //any other string is the build error text
@@ -408,7 +529,8 @@ export function buildAll(options) {
                 }
                 else {
                     if (!skipping) {
-                        log(chalk.green('Built ' + pkg.packageName) + (res === false ? chalk.redBright(' (with warnings)') : ''));
+                        log(chalk.green('Built ' + pkg.packageName) +
+                            (res === false ? chalk.redBright(' (with warnings)') : ''));
                     }
                     done.add(pkg);
                     packagesLeft--;
@@ -424,7 +546,7 @@ export function buildAll(options) {
                 }
             })
                 .catch(({ error, stdout, stderr }) => {
-                warn(chalk.red('Failed to build ' + pkg.packageName));
+                logError(chalk.red('Failed to build ' + pkg.packageName));
                 console.log(stdout);
                 process.exit(1);
                 // let dependentModules = getDependentP
@@ -607,7 +729,7 @@ const camelCase = (str) => {
     }
     return str;
 };
-export const createOntology = (prefix_1, uriBase_1, ...args_1) => __awaiter(void 0, [prefix_1, uriBase_1, ...args_1], void 0, function* (prefix, uriBase, basePath = process.cwd()) {
+export const createOntology = (prefix_1, uriBase_1, ...args_2) => __awaiter(void 0, [prefix_1, uriBase_1, ...args_2], void 0, function* (prefix, uriBase, basePath = process.cwd()) {
     if (!prefix) {
         console.warn('Please provide a suggested prefix as the first argument');
         return;
@@ -620,7 +742,7 @@ export const createOntology = (prefix_1, uriBase_1, ...args_1) => __awaiter(void
     setVariable('uri_base', uriBase);
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(prefix);
     //copy ontology accessor file
-    log('Creating files for ontology \'' + prefix + '\'');
+    log("Creating files for ontology '" + prefix + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.ts');
     fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
     //copy data files
@@ -770,7 +892,7 @@ export const getScriptDir = () => {
     //   return dirname(import.meta.url).replace('file:/','');
     // }
 };
-export const createShape = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
+export const createShape = (name_2, ...args_3) => __awaiter(void 0, [name_2, ...args_3], void 0, function* (name, basePath = process.cwd()) {
     let sourceFolder = getSourceFolder(basePath);
     let targetFolder = ensureFolderExists(sourceFolder, 'shapes');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
@@ -788,11 +910,11 @@ export const createShape = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...
         log(`Added an import of this file from ${chalk.magenta(indexPath)}`);
     }
 });
-export const createSetComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
+export const createSetComponent = (name_3, ...args_4) => __awaiter(void 0, [name_3, ...args_4], void 0, function* (name, basePath = process.cwd()) {
     let targetFolder = ensureFolderExists(basePath, 'src', 'components');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
     //copy default shape file
-    log('Creating files for set component \'' + name + '\'');
+    log("Creating files for set component '" + name + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.tsx');
     fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'set-component.tsx'), targetFile);
     let targetFile2 = path.join(targetFolder, hyphenName + '.scss');
@@ -802,12 +924,12 @@ export const createSetComponent = (name_1, ...args_1) => __awaiter(void 0, [name
     let indexPath = addLineToIndex(`import './components/${hyphenName}.js';`, 'components');
     log(`Created a new set component in ${chalk.magenta(targetFile.replace(basePath, ''))}`, `Created a new stylesheet in ${chalk.magenta(targetFile2.replace(basePath, ''))}`, `Added an import of this file from ${chalk.magenta(indexPath)}`);
 });
-export const createComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
+export const createComponent = (name_4, ...args_5) => __awaiter(void 0, [name_4, ...args_5], void 0, function* (name, basePath = process.cwd()) {
     let sourceFolder = getSourceFolder(basePath);
     let targetFolder = ensureFolderExists(sourceFolder, 'components');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
     //copy default shape file
-    log('Creating files for component \'' + name + '\'');
+    log("Creating files for component '" + name + "'");
     let targetFile = path.join(targetFolder, hyphenName + '.tsx');
     fs.copySync(path.join(getScriptDir(), '..', 'defaults', 'component.tsx'), targetFile);
     let targetFile2 = path.join(targetFolder, hyphenName + '.scss');
@@ -825,7 +947,7 @@ export const createComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1,
 //read the source of all ts/tsx files in the src folder
 //if there is an import that imports a lincd package with /src/ in it, then warn
 //if there is an import that imports something from outside the src folder, then warn
-export const checkImports = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (sourceFolder = getSourceFolder(), depth = 0, // Used to check if the import is outside the src folder
+export const checkImports = (...args_6) => __awaiter(void 0, [...args_6], void 0, function* (sourceFolder = getSourceFolder(), depth = 0, // Used to check if the import is outside the src folder
 invalidImports = new Map()) {
     const dir = fs.readdirSync(sourceFolder);
     // Start checking each file in the source folder
@@ -858,19 +980,19 @@ invalidImports = new Map()) {
             if (isImportOutsideOfPackage(i, depth)) {
                 invalidImports.get(filename).push({
                     type: 'outside_package',
-                    importPath: i
+                    importPath: i,
                 });
             }
             if (isInvalidLINCDImport(i, depth)) {
                 invalidImports.get(filename).push({
                     type: 'lincd',
-                    importPath: i
+                    importPath: i,
                 });
             }
             if (isImportWithMissingExtension(i)) {
                 invalidImports.get(filename).push({
                     type: 'missing_extension',
-                    importPath: i
+                    importPath: i,
                 });
             }
         });
@@ -884,15 +1006,17 @@ invalidImports = new Map()) {
         invalidImports.forEach((value, key) => {
             // res += '- '+chalk.blueBright(key.split('/').pop()) + ':\n';
             value.forEach(({ type, importPath }) => {
-                let message = key.split('/').pop() + ' imports from \'' + importPath + '\'';
+                let message = key.split('/').pop() + " imports from '" + importPath + "'";
                 if (type === 'outside_package') {
                     message += ' which is outside the package source root';
                 }
                 if (type === 'lincd') {
-                    message += ' which should not contain /src/ or /lib/ in the import path';
+                    message +=
+                        ' which should not contain /src/ or /lib/ in the import path';
                 }
                 if (type === 'missing_extension') {
-                    message += ' which should end with a file extension. Like .js or .scss';
+                    message +=
+                        ' which should end with a file extension. Like .js or .scss';
                 }
                 res += chalk.red(message + '\n');
             });
@@ -929,7 +1053,7 @@ export const depCheckStaged = () => __awaiter(void 0, void 0, void 0, function*
         });
     });
 });
-export const depCheck = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
+export const depCheck = (...args_7) => __awaiter(void 0, [...args_7], void 0, function* (packagePath = process.cwd()) {
     return new Promise((resolve, reject) => {
         depcheck(packagePath, {}, (results) => {
             if (results.missing) {
@@ -949,10 +1073,16 @@ export const depCheck = (...args_1) => __awaiter(void 0, [...args_1], void 0, fu
                 if (missingLincdPackages.length > 0) {
                     reject(chalk.red(packagePath.split('/').pop() +
                         '\n[ERROR] These LINCD packages are imported but they are not listed in package.json:\n- ' +
-                        missingLincdPackages.join(',\n- ')));
+                        missingLincdPackages
+                            .map((missedKey) => {
+                            const files = results.missing[missedKey];
+                            return `${missedKey} (${files.length} files: ${files.join(', ')})`;
+                        })
+                            .join(',\n- ')));
                 }
                 else if (missing.length > 0) {
-                    resolve(chalk.redBright('warning: ' + packagePath.split('/').pop() +
+                    resolve(chalk.redBright('warning: ' +
+                        packagePath.split('/').pop() +
                         ' is missing dependencies:\n  - ' +
                         missing.join('\n  - ')));
                 }
@@ -1016,9 +1146,88 @@ export const ensureEnvironmentLoaded = () => __awaiter(void 0, void 0, void 0, f
         }
     }
 });
-export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (initOnly = false, ServerClass = null) {
+export const runMethod = (packageName, method, options) => __awaiter(void 0, void 0, void 0, function* () {
+    yield ensureEnvironmentLoaded();
+    if (options.spawn) {
+        let lincdConfig = (yield import(path.join(process.cwd(), 'lincd.config.js'))).default;
+        //@ts-ignore
+        const ServerClass = (yield import('lincd-server/shapes/LincdServer'))
+            .LincdServer;
+        yield import(path.join(process.cwd(), 'scripts', 'storage-config.js'));
+        let server = new ServerClass(Object.assign({ loadAppComponent: () => __awaiter(void 0, void 0, void 0, function* () { return (yield import(path.join(process.cwd(), 'src', 'App'))).default; }) }, lincdConfig));
+        //init the server
+        console.log('Initializing server...');
+        server.initOnly().then(() => {
+            //process the backend method call
+            console.log('Running method ' + method);
+            //mock the request and response objects
+            let request = {
+                body: {},
+                query: {},
+                params: {},
+                headers: {},
+                method: 'POST',
+                url: '/' + packageName + '/' + method,
+            };
+            let response = {
+                status: (statusCode) => {
+                    console.log('Response status code:', statusCode);
+                    return response;
+                },
+                json: (data) => {
+                    console.log('Response data:', data);
+                },
+                send: (data) => {
+                    console.log('Response data:', data);
+                },
+            };
+            //TODO; allow sending args
+            server
+                .callBackendMethod(packageName, method, [], request, response)
+                .then(() => {
+                console.log('Done');
+                process.exit();
+            });
+        });
+    }
+    else {
+        //reuse the existing running LincdServer instance.
+        //make a HTTP call
+        //'/call/:pkg/:method',
+        fetch(process.env.SITE_ROOT + '/call/' + packageName + '/' + method, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        })
+            .then((response) => {
+            if (!response.ok) {
+                throw new Error('Network response was not ok');
+            }
+            return response.json();
+        })
+            .then((data) => {
+            console.log('Response data:', data);
+            process.exit();
+        })
+            .catch((error) => {
+            var _a;
+            if (error.code === 'ECONNREFUSED' ||
+                ((_a = error.cause) === null || _a === void 0 ? void 0 : _a.code) === 'ECONNREFUSED') {
+                console.error(chalk.red('Could not connect to the backend server. Is it running?'));
+                console.error(`Make sure you ${chalk.magenta('run "yarn start" in a separate process')} before calling this method.`);
+            }
+            else {
+                console.error('Error during backend call:', error);
+            }
+            process.exit(1);
+        });
+    }
+});
+export const startServer = (...args_8) => __awaiter(void 0, [...args_8], void 0, function* (initOnly = false, ServerClass = null) {
     yield ensureEnvironmentLoaded();
-    let lincdConfig = (yield import(path.join(process.cwd(), 'lincd.config.js'))).default;
+    let lincdConfig = (yield import(path.join(process.cwd(), 'lincd.config.js')))
+        .default;
     // function scssLoadcall(source, filename) {
     //   return 'console.log("SCSS CALL: ' + filename + '");\n' + source;
     //   process.exit();
@@ -1034,7 +1243,18 @@ export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0,
         ServerClass = (yield import('lincd-server/shapes/LincdServer')).LincdServer;
     }
     yield import(path.join(process.cwd(), 'scripts', 'storage-config.js'));
-    let server = new ServerClass(Object.assign({ loadAppComponent: () => __awaiter(void 0, void 0, void 0, function* () { return (yield import(path.join(process.cwd(), 'src', 'App'))).default; }) }, lincdConfig));
+    let appPromise;
+    if (process.env.NODE_ENV !== 'development') {
+        appPromise = (yield import(path.join(process.cwd(), 'lib', 'App.js')))
+            .default;
+    }
+    else {
+        appPromise = (yield import(path.join(process.cwd(), 'src', 'App.tsx')))
+            .default;
+    }
+    let server = new ServerClass(Object.assign({ loadAppComponent: () => __awaiter(void 0, void 0, void 0, function* () {
+            return appPromise;
+        }) }, lincdConfig));
     //Important to use slice, because when using clusers, child processes need to be able to read the same arguments
     let args = process.argv.slice(2);
     //if --initOnly is passed, only initialize the server and don't start it
@@ -1046,10 +1266,15 @@ export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0,
     }
 });
 export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield buildFrontend();
+    yield buildBackend();
+    console.log(chalk.magenta(`✅ ${process.env.NODE_ENV} app build finished`));
+});
+export const buildFrontend = () => __awaiter(void 0, void 0, void 0, function* () {
     yield ensureEnvironmentLoaded();
     const webpackAppConfig = yield (yield import('./config-webpack-app.js')).getWebpackAppConfig();
-    console.log(chalk.magenta(`Building ${process.env.NODE_ENV} app bundles`));
-    return new Promise((resolve, reject) => {
+    console.log(chalk.magenta(`🛠 Building ${process.env.NODE_ENV} frontend bundles`));
+    yield new Promise((resolve, reject) => {
         webpack(webpackAppConfig, (err, stats) => __awaiter(void 0, void 0, void 0, function* () {
             if (err) {
                 console.error(err.stack || err);
@@ -1085,13 +1310,16 @@ export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
     }).then(() => __awaiter(void 0, void 0, void 0, function* () {
         // make sure environment is not development for storage config
         // and if we want to upload to storage, we need set S3_BUCKET_ENDPOINT
-        if (process.env.NODE_ENV === 'development' || !process.env.S3_BUCKET_ENDPOINT) {
+        if (process.env.NODE_ENV === 'development' ||
+            !process.env.S3_BUCKET_ENDPOINT) {
             console.warn('Upload build to storage skip in development environment or S3_BUCKET_ENDPOINT is not set');
-            process.exit();
+            return;
+            // process.exit();
         }
         if (process.env.APP_ENV) {
             console.warn('Not uploading to CDN for app builds');
-            process.exit();
+            return;
+            // process.exit();
         }
         // load the storage config
         const storageConfig = yield import(path.join(process.cwd(), 'scripts', 'storage-config.js'));
@@ -1107,6 +1335,12 @@ export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
             }
             // get all files in the web directory and then upload them to the storage
             const files = yield getFiles(pathDir);
+            console.log(chalk.magenta(`🕊  Publishing ${files.length} public files to linked file storage`));
+            const clearSpinner = ora({
+                discardStdin: true,
+                text: `Publishing ${files.length} public files`,
+            }).start();
+            let counter = 0;
             const uploads = files.map((filePath) => __awaiter(void 0, void 0, void 0, function* () {
                 // read file content
                 const fileContent = yield fs.promises.readFile(filePath);
@@ -1114,14 +1348,77 @@ export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
                 // example: /Users/username/project/www/index.html -> /project/www/index.html
                 const pathname = filePath.replace(pathDir, `/${rootDirectory}`);
                 // upload file to storage
-                return yield LinkedFileStorage.saveFile(pathname, fileContent);
+                yield LinkedFileStorage.saveFile(pathname, fileContent)
+                    .then(() => {
+                    clearSpinner.text = `${counter++}/${files.length}: - Published ${pathname} `;
+                })
+                    .catch(console.error);
             }));
             const urls = yield Promise.all(uploads);
-            console.log(`${urls.length} files uploaded to storage`);
-            process.exit();
+            clearSpinner.succeed(`${urls.length} files uploaded to storage`);
         }
     }));
 });
+export const buildBackend = () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(chalk.magenta(`🛠 Preparing ${process.env.NODE_ENV} backend`));
+    //run tsc in the backend folder
+    yield ensureEnvironmentLoaded();
+    const sourceFolder = path.join(process.cwd(), 'src');
+    const targetFolder = path.join(process.cwd(), 'lib');
+    // Step 1: Clear lib folder
+    const clearSpinner = ora({
+        discardStdin: true,
+        text: 'Clearing lib folder',
+    }).start();
+    try {
+        if (fs.existsSync(targetFolder)) {
+            yield fs.remove(targetFolder);
+        }
+        clearSpinner.succeed('Lib folder cleared');
+    }
+    catch (e) {
+        console.error(e);
+        clearSpinner.fail('Failed to clear lib folder');
+        return;
+    }
+    // Step 2: Compile TS files
+    const compileSpinner = ora({
+        discardStdin: true,
+        text: 'Compiling backend TS files',
+    }).start();
+    try {
+        yield execPromise(`yarn exec tsc`);
+        compileSpinner.succeed('Backend TS files compiled');
+    }
+    catch (e) {
+        console.error(e);
+        compileSpinner.fail('Failed to compile backend TS files');
+        return;
+    }
+    // Step 3: Copy CSS files
+    const copySpinner = ora({
+        discardStdin: true,
+        text: 'Copying CSS files',
+    }).start();
+    try {
+        const cssFiles = yield getFiles(sourceFolder, '.css');
+        yield Promise.all(cssFiles.map((file) => {
+            const targetFile = file.replace(sourceFolder, targetFolder);
+            //ensure the target folder exists
+            const targetDir = path.dirname(targetFile);
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+            return fs.copyFile(file, targetFile);
+        }));
+        copySpinner.succeed(`${cssFiles.length} CSS files copied`);
+    }
+    catch (e) {
+        console.error(e);
+        copySpinner.fail('Failed to copy CSS files');
+    }
+    return true;
+});
 export const upgradePackages = () => __awaiter(void 0, void 0, void 0, function* () {
     yield ensureEnvironmentLoaded();
     // let packages = getLincdPackages();
@@ -1131,7 +1428,9 @@ export const upgradePackages = () => __awaiter(void 0, void 0, void 0, function*
     const tsConfigCJS = path.join(dirname, '../../defaults/package', 'tsconfig-cjs.json');
     const tsConfigESM = path.join(dirname, '../../defaults/package', 'tsconfig-esm.json');
     const typesFile = path.join(dirname, '../../defaults/package/src', 'types.d.ts');
-    const tsConfigTemplate = yield fs.readJson(path.join(dirname, '../../defaults/package', 'tsconfig.json')).catch(err => {
+    const tsConfigTemplate = yield fs
+        .readJson(path.join(dirname, '../../defaults/package', 'tsconfig.json'))
+        .catch((err) => {
         console.log(err);
     });
     runOnPackagesGroupedByDependencies(packages, (packageGroup, dependencies) => {
@@ -1246,7 +1545,9 @@ export const upgradePackages = () => __awaiter(void 0, void 0, void 0, function*
             //     }
             //   })
             // });
-            files.filter(f => f.match(/\.(scss\.json|css\.json)$/)).forEach(cssJsonFile => {
+            files
+                .filter((f) => f.match(/\.(scss\.json|css\.json)$/))
+                .forEach((cssJsonFile) => {
                 console.log('Removing ' + cssJsonFile);
                 fs.unlinkSync(cssJsonFile);
             });
@@ -1264,7 +1565,7 @@ export const upgradePackages = () => __awaiter(void 0, void 0, void 0, function*
     // })
     // });
 });
-export const createPackage = (name_1, uriBase_1, ...args_1) => __awaiter(void 0, [name_1, uriBase_1, ...args_1], void 0, function* (name, uriBase, basePath = process.cwd()) {
+export const createPackage = (name_5, uriBase_2, ...args_9) => __awaiter(void 0, [name_5, uriBase_2, ...args_9], void 0, function* (name, uriBase, basePath = process.cwd()) {
     if (!name) {
         console.warn('Please provide a name as the first argument');
         return;
@@ -1295,7 +1596,7 @@ export const createPackage = (name_1, uriBase_1, ...args_1) => __awaiter(void 0,
     //extra variable for clarity (will be same as 'name')
     setVariable('output_file_name', name);
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(cleanPackageName);
-    log('Creating new LINCD package \'' + name + '\'');
+    log("Creating new LINCD package '" + name + "'");
     fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'package'), targetFolder);
     //replace variables in some of the copied files
     yield Promise.all([
@@ -1397,7 +1698,7 @@ export const register = function (registryURL) {
         console.warn(chalk.red('Warning:') + ' not found: ' + process.cwd() + '/package.json');
     }
 };
-export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0, [target_1, target2_1, ...args_1], void 0, function* (target, target2, packagePath = process.cwd(), logResults = true) {
+export const buildPackage = (target_1, target2_1, ...args_10) => __awaiter(void 0, [target_1, target2_1, ...args_10], void 0, function* (target, target2, packagePath = process.cwd(), logResults = true) {
     let spinner;
     if (logResults) {
         //TODO: replace with listr so we can show multiple processes at once
@@ -1416,7 +1717,7 @@ export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0
                 spinner.text = step.name;
                 spinner.start();
             }
-            return step.apply().then(stepResult => {
+            return step.apply().then((stepResult) => {
                 //if a build step returns a string,
                 //a warning is shown but the build is still successful with warnings
                 if (typeof stepResult === 'string') {
@@ -1445,6 +1746,10 @@ export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0
             });
         });
     };
+    buildStep({
+        name: 'Checking imports',
+        apply: () => checkImports(packagePath + '/src'),
+    });
     buildStep({
         name: 'Compiling ESM',
         apply: () => __awaiter(void 0, void 0, void 0, function* () {
@@ -1461,26 +1766,29 @@ export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0
         name: 'Copying files to lib folder',
         apply: () => __awaiter(void 0, void 0, void 0, function* () {
             const files = yield glob(packagePath + '/src/**/*.{json,d.ts,css,scss}');
-            return Promise.all(files.map(((file) => __awaiter(void 0, void 0, void 0, function* () {
+            return Promise.all(files.map((file) => __awaiter(void 0, void 0, void 0, function* () {
                 try {
-                    yield fs.copy(file, packagePath + '/lib/esm/' + file.replace(packagePath + '/src/', ''));
-                    yield fs.copy(file, packagePath + '/lib/cjs/' + file.replace(packagePath + '/src/', ''));
+                    yield fs.copy(file, packagePath +
+                        '/lib/esm/' +
+                        file.replace(packagePath + '/src/', ''));
+                    yield fs.copy(file, packagePath +
+                        '/lib/cjs/' +
+                        file.replace(packagePath + '/src/', ''));
                     return true;
                 }
                 catch (err) {
                     console.warn(err);
                     return false;
                 }
-                ;
-            })))).then((allResults) => {
-                return allResults.every(r => r === true);
+            }))).then((allResults) => {
+                return allResults.every((r) => r === true);
             });
         }),
     });
     buildStep({
         name: 'Dual package support',
         apply: () => {
-            return execPromise('yarn tsconfig-to-dual-package ./tsconfig-cjs.json ./tsconfig-esm.json', false, false, { cwd: packagePath }).then(res => {
+            return execPromise('yarn tsconfig-to-dual-package ./tsconfig-cjs.json ./tsconfig-esm.json', false, false, { cwd: packagePath }).then((res) => {
                 return res === '';
             });
         },
@@ -1491,16 +1799,16 @@ export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0
             return removeOldFiles(packagePath);
         }),
     });
-    buildStep({
-        name: 'Checking imports',
-        apply: () => checkImports(packagePath),
-    });
     buildStep({
         name: 'Checking dependencies',
         apply: () => depCheck(packagePath),
     });
-    let success = yield buildProcess.catch(err => {
-        let msg = typeof err === 'string' || err instanceof Error ? err.toString() : (err.error && !err.error.toString().includes("Command failed:") ? err.error : err.stdout + '\n' + err.stderr);
+    let success = yield buildProcess.catch((err) => {
+        let msg = typeof err === 'string' || err instanceof Error
+            ? err.toString()
+            : err.error && !err.error.toString().includes('Command failed:')
+                ? err.error
+                : err.stdout + '\n' + err.stderr;
         if (logResults) {
             spinner.stopAndPersist({
                 symbol: chalk.red('✖'),
@@ -1518,19 +1826,23 @@ export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0
         if (logResults) {
             spinner.stopAndPersist({
                 symbol: chalk.greenBright('✔'),
-                text: success === true ? 'Build successful' : 'Build successful with warnings',
+                text: success === true
+                    ? 'Build successful'
+                    : 'Build successful with warnings',
             });
         }
     }
     else {
-        spinner.stopAndPersist({
-            symbol: chalk.red('✖'),
-            text: 'Build failed',
-        });
+        if (logResults) {
+            spinner.stopAndPersist({
+                symbol: chalk.red('✖'),
+                text: 'Build failed',
+            });
+        }
     }
     return success;
 });
-export const compilePackage = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
+export const compilePackage = (...args_11) => __awaiter(void 0, [...args_11], void 0, function* (packagePath = process.cwd()) {
     //echo 'compiling CJS' && tsc -p tsconfig-cjs.json && echo 'compiling ESM' && tsc -p tsconfig-esm.json
     // let cjsConfig = fs.existsSync(path.join(packagePath,'tsconfig-cjs.json'));
     // let esmConfig = fs.existsSync(path.join(packagePath,'tsconfig-esm.json'));
@@ -1556,20 +1868,22 @@ export const compilePackage = (...args_1) => __awaiter(void 0, [...args_1], void
     yield compilePackageESM(packagePath);
     yield compilePackageCJS(packagePath);
 });
-export const compilePackageESM = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
+export const compilePackageESM = (...args_12) => __awaiter(void 0, [...args_12], void 0, function* (packagePath = process.cwd()) {
     //echo 'compiling CJS' && tsc -p tsconfig-cjs.json && echo 'compiling ESM' && tsc -p tsconfig-esm.json
     let compileCommand = `yarn exec tsc -p tsconfig-esm.json`;
-    return execPromise(compileCommand, false, false, { cwd: packagePath }).then(res => {
+    return execPromise(compileCommand, false, false, { cwd: packagePath }).then((res) => {
         return res === '';
     });
 });
-export const compilePackageCJS = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
+export const compilePackageCJS = (...args_13) => __awaiter(void 0, [...args_13], void 0, function* (packagePath = process.cwd()) {
     let compileCommand = `yarn exec tsc -p tsconfig-cjs.json`;
-    return execPromise(compileCommand, false, false, { cwd: packagePath }).then(res => {
+    return execPromise(compileCommand, false, false, { cwd: packagePath })
+        .then((res) => {
         return res === '';
-    }).catch(err => {
+    })
+        .catch((err) => {
         return {
-            error: err.stdout
+            error: err.stdout,
         };
     });
 });
@@ -1684,7 +1998,7 @@ export var publishUpdated = function (test = false) {
             }))
                 .catch(({ error, stdout, stderr }) => {
                 if (error) {
-                    console.log(error.message);
+                    console.error(error.message);
                 }
                 if (stdout) {
                     console.log(stderr);
@@ -1762,7 +2076,7 @@ export var publishPackage = function (pkg, test, info, publishVersion) {
             .then((res) => {
             if (res.indexOf('Aborted due to warnings') !== -1 ||
                 res.indexOf('Could not publish') !== -1 ||
-                res.indexOf('Couldn\'t publish') !== -1) {
+                res.indexOf("Couldn't publish") !== -1) {
                 console.log(res);
                 return chalk.red(pkg.packageName + ' failed\n');
             }
@@ -1775,7 +2089,7 @@ export var publishPackage = function (pkg, test, info, publishVersion) {
                 chalk.magenta(publishVersion));
         })
             .catch(({ error, stdout, stderr }) => {
-            console.log(chalk.red('Failed to publish: ' + error.message));
+            logError('Failed to publish: ' + error.message);
             return chalk.red(pkg.packageName + ' failed to publish');
         });
     });
@@ -1792,16 +2106,26 @@ export var buildUpdated = function (back_1, target_1, target2_1) {
         // let packages = getLocalLincdModules();
         let packages = getLocalLincdPackageMap();
         // console.log(packages);
-        let jsonldPkgUpdated = yield needsRebuilding(packages.get('lincd-jsonld'), useGitForLastModified);
+        // let jsonldPkgUpdated = await needsRebuilding(
+        //   packages.get('lincd-jsonld'),
+        //   useGitForLastModified,
+        // );
         // let cliPkgUpdated = await needsRebuilding(packages.get('lincd-cli'), useGitForLastModified);
         //if either cli or jsonldPkg needs to be rebuilt
         // if (jsonldPkgUpdated || cliPkgUpdated) {
-        if (jsonldPkgUpdated) {
-            yield execPromise('yarn exec tsc && echo "compiled lincd-jsonld"', false, false, {
-                cwd: packages.get('lincd-jsonld').path,
-            }, true);
-            // await execPromise('yarn build-core', false, false, {}, true);
-        }
+        // if (jsonldPkgUpdated)
+        // {
+        //   await execPromise(
+        //     'yarn exec tsc && echo "compiled lincd-jsonld"',
+        //     false,
+        //     false,
+        //     {
+        //       cwd: packages.get('lincd-jsonld').path,
+        //     },
+        //     true,
+        //   );
+        //   // await execPromise('yarn build-core', false, false, {}, true);
+        // }
         let rebuildAllModules = false;
         // if (cliPkgUpdated) {
         //   rebuildAllModules = true;
@@ -1815,9 +2139,10 @@ export var buildUpdated = function (back_1, target_1, target2_1) {
             return (pkg) => __awaiter(this, void 0, void 0, function* () {
                 // debugInfo('# Checking package ' + pkg.packageName);
                 let needRebuild = yield needsRebuilding(pkg, useGitForLastModified);
-                if (pkg.packageName === 'lincd-jsonld' && jsonldPkgUpdated) {
-                    needRebuild = true;
-                }
+                // if (pkg.packageName === 'lincd-jsonld' && jsonldPkgUpdated)
+                // {
+                //   needRebuild = true;
+                // }
                 if (needRebuild || rebuildAllModules) {
                     //TODO: when building a pkg, also rebuild all packages that depend on this package.. and iteratively build packages that depend on those packages..
                     // log(packageName+' modified since last commit on '+now.toString());
@@ -1826,42 +2151,31 @@ export var buildUpdated = function (back_1, target_1, target2_1) {
                         return chalk.blue(pkg.packageName + ' should be build');
                     }
                     log('Building ' + pkg.packageName);
-                    // return buildPackage(null,null,pkg.path)
-                    return execPromise('cd ' +
-                        pkg.path +
-                        ' && yarn build' +
-                        (target ? ' ' + target : '') +
-                        (target2 ? ' ' + target2 : ''))
+                    return buildPackage(null, null, path.join(process.cwd(), pkg.path), false)
                         .then((res) => {
-                        if (res === '') {
+                        //empty string or true is success
+                        //false is success with warnings
+                        //any other string is the build error text
+                        //undefined result means it failed
+                        if (typeof res === 'undefined') {
+                            logError('Failed to build ' + pkg.packageName);
+                            process.exit(1);
+                        }
+                        else {
                             debugInfo(chalk.green(pkg.packageName + ' successfully built'));
                             return chalk.green(pkg.packageName + ' built');
                         }
-                        else if (typeof res === 'string') {
-                            warn(chalk.red('Failed to build ' + pkg.packageName));
-                            // console.log(res);
-                            process.exit(1);
-                        }
                     })
-                        .catch(({ error, stdout, stderr }) => {
-                        warn(chalk.red('Failed to build ' + pkg.packageName));
-                        console.log(stdout);
+                        .catch((err) => {
+                        logError('Failed to build ' + pkg.packageName);
+                        console.error(err);
                         process.exit(1);
-                        // let dependentModules = getDependentPackages(dependencies, pkg);
-                        // if (dependentModules.length > 0) {
-                        //   // printBuildResults(failedModules, done);
-                        //   warn(chalk.red(pkg.packageName + ' build failed'));
-                        //   warn(
-                        //     'Stopping build-updated process because ' +
-                        //       dependentModules.length +
-                        //       ' other packages depend on this package.\n',
-                        //   ); //"+dependentModules.map(d => d.packageName).join(", ")));
-                        // }
                     });
                 }
             });
-        }, (results) => {
+        }, (dependencies, results) => {
             if (results.length) {
+                log(chalk.green('Changed packages have been rebuilt'));
                 log('Summary:');
                 log(results.join('\n'));
             }
@@ -1901,16 +2215,15 @@ export var executeCommandForEachPackage = function (packages, command, filterMet
         }
         let seen = false;
         packages = packages.filter((pkg) => {
-            if (!seen &&
-                pkg.packageName.includes(startFrom)) {
+            if (!seen && pkg.packageName.includes(startFrom)) {
                 seen = true;
             }
             return seen;
         });
     }
-    log('Executing \'' +
+    log("Executing '" +
         chalk.blueBright(command) +
-        '\' on packages ' +
+        "' on packages " +
         chalk.magenta(packages.map((m) => m.packageName).join(', ')));
     var p = Promise.resolve(true);
     packages.forEach((pkg) => {
@@ -1993,20 +2306,19 @@ export var executeCommandForPackage = function (packageName, command) {
     let packageDetails = getLincdPackages().find((modDetails) => modDetails.packageName.indexOf(packageName) !== -1 ||
         modDetails.packageName.indexOf(packageName) !== -1);
     if (packageDetails) {
-        log('Executing \'cd ' +
+        log("Executing 'cd " +
             packageDetails.path +
-            ' && yarn exec lincd' +
+            ' && yarn lincd' +
             (command ? ' ' + command : '') +
-            '\'');
-        //TODO : replace with spawn("path to executable", ["params"], {stdio: "inherit"});
-        // maybe make spawnPromise that returns a promise
-        return execp('cd ' +
-            packageDetails.path +
-            ' && yarn exec lincd' +
-            (command ? ' ' + command : ''));
+            "'");
+        spawnChild(process.platform === 'win32' ? 'yarn.cmd' : 'yarn', // Windows quirk
+        ['lincd', command || null], {
+            cwd: packageDetails.path,
+            stdio: 'inherit',
+        });
     }
     else {
-        warn('Could not find a pkg who\'s name (partially) matched ' +
+        warn("Could not find a pkg who's name (partially) matched " +
             chalk.cyan(packageName));
     }
 };