@symbo.ls/cli 2.11.309 → 2.11.315

package/bin/fetch.js

@@ -1,132 +1,140 @@
 #!/usr/bin/env node
 
-import fs from 'fs'
-import chalk from 'chalk'
-import { loadModule } from './require.js'
-import { program } from './program.js'
-import * as fetch from '@symbo.ls/fetch'
-import * as utils from '@domql/utils'
-import { convertFromCli } from './convert.js'
-import { createDirs } from './fs.js'
-
-const { isObjectLike } = utils.default
-const { fetchRemote } = fetch.default
-
-const RC_PATH = process.cwd() + '/symbols.json'
+import fs from "fs";
+import chalk from "chalk";
+import { loadModule } from "./require.js";
+import { program } from "./program.js";
+import * as fetch from "@symbo.ls/fetch";
+import * as utils from "@domql/utils";
+import { convertFromCli } from "./convert.js";
+import { createFs } from "./fs.js";
+
+const { isObjectLike } = utils.default;
+const { fetchRemote } = fetch.default;
+
+const RC_PATH = process.cwd() + "/symbols.json";
 const LOCAL_CONFIG_PATH =
-  process.cwd() + '/node_modules/@symbo.ls/init/dynamic.json'
-const DEFAULT_REMOTE_REPOSITORY = 'https://github.com/symbo-ls/default-config/'
+  process.cwd() + "/node_modules/@symbo.ls/init/dynamic.json";
+const DEFAULT_REMOTE_REPOSITORY = "https://github.com/symbo-ls/default-config/";
 const DEFAULT_REMOTE_CONFIG_PATH = "https://api.symbols.app/"; // eslint-disable-line
 
-const API_URL_LOCAL = 'http://localhost:13335/get/'
-const API_URL = 'https://api.symbols.app/get/'
+const API_URL_LOCAL = "http://localhost:13335/get/";
+const API_URL = "https://api.symbols.app/get/";
 
 const rcFile = loadModule(RC_PATH); // eslint-disable-line
 const localConfig = loadModule(LOCAL_CONFIG_PATH); // eslint-disable-line
 
 const debugMsg = chalk.dim(
-  'Use --verbose to debug the error or open the issue at https://github.com/symbo-ls/smbls'
-)
+  "Use --verbose to debug the error or open the issue at https://github.com/symbo-ls/smbls"
+);
 
-let rc = {}
+let rc = {};
 try {
   rc = loadModule(RC_PATH); // eslint-disable-line
 } catch (e) {
-  console.error('Please include symbols.json to your root of respository')
+  console.error("Please include symbols.json to your root of respository");
 }
 
 export const fetchFromCli = async (opts) => {
-  const { dev, verbose, prettify, convert: convertOpt } = opts
-
+  const { dev, verbose, prettify, convert: convertOpt, update } = opts;
   await rc.then(async (data) => {
-    const { key, framework, distDir } = data
+    const { key, framework, distDir } = data;
 
-    const endpoint = dev ? API_URL_LOCAL : API_URL
+    const endpoint = dev ? API_URL_LOCAL : API_URL;
 
-    console.log('\nFetching from:', chalk.bold(endpoint), '\n')
+    console.log("\nFetching from:", chalk.bold(endpoint), "\n");
 
     const body = await fetchRemote(key, {
       endpoint,
       onError: (e) => {
-        console.log(chalk.red('Failed to fetch:'), key)
-        if (verbose) console.error(e)
-        else console.log(debugMsg)
-      }
-    })
+        console.log(chalk.red("Failed to fetch:"), key);
+        if (verbose) console.error(e);
+        else console.log(debugMsg);
+      },
+    });
 
-    if (!body) return
+    if (!body) return;
 
-    const { version, ...config } = body
+    const { version, ...config } = body;
 
     if (verbose) {
       if (key) {
         console.log(
-          chalk.bold('Symbols'),
-          'data fetched for',
+          chalk.bold("Symbols"),
+          "data fetched for",
           chalk.green(body.name)
-        )
+        );
       } else {
         console.log(
-          chalk.bold('Symbols'),
-          'config fetched from',
-          chalk.bold('default-config from:'),
+          chalk.bold("Symbols"),
+          "config fetched from",
+          chalk.bold("default-config from:"),
           chalk.dim.underline(DEFAULT_REMOTE_REPOSITORY)
-        )
+        );
       }
-      console.log()
+      console.log();
     }
 
     for (const t in config) {
-      const type = config[t]
-      const arr = []
+      const type = config[t];
+      const arr = [];
       if (isObjectLike(type)) {
-        for (const v in type) arr.push(v)
+        for (const v in type) arr.push(v);
         if (arr.length) {
-          console.log(chalk.dim(t + ':'))
-          console.log(chalk.bold(arr.join(', ')))
+          console.log(chalk.dim(t + ":"));
+          console.log(chalk.bold(arr.join(", ")));
         } else {
-          console.log(chalk.dim(t + ':'), chalk.dim('- empty -'))
+          console.log(chalk.dim(t + ":"), chalk.dim("- empty -"));
         }
-      } else console.log(chalk.dim(t + ':'), chalk.bold(type))
+      } else console.log(chalk.dim(t + ":"), chalk.bold(type));
     }
 
     if (body.designsystem) {
-      body.designSystem = body.designsystem
-      delete body.designsystem
+      body.designSystem = body.designsystem;
+      delete body.designsystem;
     }
 
-    const bodyString = JSON.stringify(body, null, prettify ?? 2)
+    const bodyString = JSON.stringify(body, null, prettify ?? 2);
 
     try {
-      await fs.writeFileSync(LOCAL_CONFIG_PATH, bodyString)
+      await fs.writeFileSync(LOCAL_CONFIG_PATH, bodyString);
 
       if (verbose) {
-        console.log(chalk.dim('\ndynamic.json has been updated:'))
-        console.log(chalk.dim.underline(LOCAL_CONFIG_PATH))
+        console.log(chalk.dim("\ndynamic.json has been updated:"));
+        console.log(chalk.dim.underline(LOCAL_CONFIG_PATH));
       }
 
-      console.log(chalk.bold.green('\nSuccessfully wrote file'))
+      console.log(chalk.bold.green("\nSuccessfully wrote file"));
     } catch (e) {
-      console.log(chalk.bold.red('\nError writing file'))
-      if (verbose) console.error(e)
-      else console.log(debugMsg)
+      console.log(chalk.bold.red("\nError writing file"));
+      if (verbose) console.error(e);
+      else console.log(debugMsg);
     }
 
-    console.log(convertOpt)
+    console.log(convertOpt);
     if (body.components && convertOpt && framework) {
-      convertFromCli(body.components, { ...opts, framework })
+      convertFromCli(body.components, { ...opts, framework });
     }
 
-    console.log(Object.keys(body))
-    createDirs(body, distDir)
-  })
-}
+    if (update) {
+      createFs(body, distDir, update);
+    } else {
+      createFs(body, distDir);
+    }
+  });
+};
 
 program
-  .command('fetch')
-  .description('Fetch Symbols')
-  .option('-d, --dev', 'Running from local server')
-  .option('-v, --verbose', 'Verbose errors and warnings')
-  .option('--convert', 'Verbose errors and warnings', true)
-  .option('--verbose-code', 'Verbose errors and warnings')
-  .action(fetchFromCli)
+  .command("fetch")
+  .description("Fetch Symbols")
+  .option("-d, --dev", "Running from local server")
+  .option("-v, --verbose", "Verbose errors and warnings")
+  .option("--convert", "Verbose errors and warnings", true)
+  .option("--update", "overriding changes from platform")
+  .option("--verbose-code", "Verbose errors and warnings")
+  .action(fetchFromCli);
+
+// program
+//   .command("push")
+//   .description("Push changes to platform")
+//   .action(fetchFromCli({ cache: true }));

package/bin/fs.js

@@ -1,97 +1,294 @@
-'use strict'
-
 import fs from 'fs'
+import chalk from 'chalk'
 import path from 'path'
 import utils from '@domql/utils'
-const { deepDestringify, objectToString, joinArrays } = utils
+import inquirer from 'inquirer'
+import { createPatch } from 'diff'
+
+const { deepDestringify, objectToString, joinArrays, isString } = utils
 
 const keys = ['components', 'snippets', 'pages']
 const singleFileKeys = ['designSystem', 'state']
+const defaultExports = ['pages', 'designSystem', 'state']
 
-export function createDirs (body, distDir) {
+export async function createFs (
+  body,
+  distDir = path.join(process.cwd(), 'dist'),
+  update = false
+) {
   if (!body) {
     console.error('No JSON object provided. Exiting.')
     return
   }
 
-  distDir = distDir || path.join(process.cwd(), 'dist')
+  const targetDir = distDir
+
+  const filesExist = fs.existsSync(targetDir)
+
+  if (!filesExist || update) {
+    await fs.promises.mkdir(targetDir, { recursive: true })
+
+    const promises = [
+      ...keys.map((key) =>
+        createKeyDirectoryAndFiles(key, body, targetDir, update)
+      ),
+      ...singleFileKeys.map((key) => {
+        if (body[key] && typeof body[key] === 'object') {
+          return createSingleFileFolderAndFile(
+            key,
+            body[key],
+            targetDir,
+            update
+          )
+        }
+      })
+    ]
+
+    await Promise.all(promises)
+    await generateIndexjsFile(joinArrays(keys, singleFileKeys), targetDir, 'root')
+  }
+
+  if (filesExist) {
+    const cacheDir = path.join(distDir, '.cache')
+    await fs.promises.mkdir(cacheDir, { recursive: true })
+
+    const cachePromises = [
+      ...keys.map((key) =>
+        createKeyDirectoryAndFiles(key, body, cacheDir, true)
+      ),
+      ...singleFileKeys.map((key) => {
+        if (body[key] && typeof body[key] === 'object') {
+          return createSingleFileFolderAndFile(key, body[key], cacheDir, true)
+        }
+      })
+    ]
 
-  keys.forEach((key) => {
-    createKeyDirectoryAndFiles(key, body, distDir)
-  })
+    await Promise.all(cachePromises)
+    await generateIndexjsFile(joinArrays(keys, singleFileKeys), cacheDir, 'root')
+
+    const diffs = await findDiff(cacheDir, targetDir)
+    if (diffs.length > 0) {
+      console.log('Differences found:')
+      diffs.forEach((diff) => {
+        console.log(chalk.green(`File: ${diff.file}`))
+        console.log(chalk.yellow('Diff:'))
+        console.log(chalk.yellow(diff.diff))
+        console.log('---')
+      })
+      if (!update) {
+        const { consent } = await askForConsent()
+        if (consent) {
+          await overrideFiles(cacheDir, targetDir)
+          console.log('Files overridden successfully.')
+        } else {
+          console.log('Files not overridden.')
+        }
+      } else {
+        await overrideFiles(cacheDir, targetDir)
+        console.log('Files overridden successfully.')
+      }
+    } else {
+      console.log('No differences found.')
+    }
+  }
+
+  async function createKeyDirectoryAndFiles (key, body, distDir, update) {
+    const dirPath = path.join(distDir, key)
+    await fs.promises.mkdir(dirPath, { recursive: true })
+
+    const dirs = []
 
-  singleFileKeys.forEach((key) => {
     if (body[key] && typeof body[key] === 'object') {
-      createSingleFileFolderAndFile(key, body[key], distDir)
+      const promises = Object.entries(body[key]).map(
+        async ([entryKey, value]) => {
+          // if pages
+          if (entryKey.startsWith('/')) entryKey = entryKey.slice(1)
+          if (entryKey === '') entryKey = 'main'
+          if (entryKey.includes('*')) entryKey = 'fallback'
+
+          await createOrUpdateFile(dirPath, entryKey, value, update)
+          dirs.push(entryKey)
+        }
+      )
+
+      await Promise.all(promises)
     }
-  })
 
-  generateRootIndexjsFile(joinArrays(keys, singleFileKeys), distDir)
-}
+    await generateIndexjsFile(dirs, dirPath, key)
+  }
 
-async function generateIndexjsFile (dirs, dirPath) {
-  const indexContent = dirs.map(d => `export * from './${d}'`).join('\n') + '\n'
-  const indexFilePath = path.join(dirPath, 'index.js')
-  const fh = await fs.promises.open(indexFilePath, 'w')
-  await fh.writeFile(indexContent, 'utf8')
-  await fh.close()
-}
+  async function createOrUpdateFile (dirPath, childKey, value, update) {
+    const filePath = path.join(dirPath, `${childKey}.js`)
 
-async function generateRootIndexjsFile (dirs, dirPath) {
-  const indexContent = dirs.map(d => {
-    const isSingleFile = singleFileKeys.includes(d)
-    if (isSingleFile) return `export { default as ${d} } from './${d}'`
-    return `export * as ${d} from './${d}'`
-  }).join('\n') + '\n'
-  const indexFilePath = path.join(dirPath, 'index.js')
-  const fh = await fs.promises.open(indexFilePath, 'w')
-  await fh.writeFile(indexContent, 'utf8')
-  await fh.close()
+    if (!update && fs.existsSync(filePath)) {
+      return
+    }
+
+    let stringifiedContent
+    if (isString(value)) {
+      stringifiedContent = `export const ${childKey} = ${value}`
+    } else {
+      const content = deepDestringify(value)
+      stringifiedContent = `export const ${childKey} = ${objectToString(content)};`
+    }
+
+    await fs.promises.writeFile(filePath, stringifiedContent, 'utf8')
+  }
+
+  async function createSingleFileFolderAndFile (key, data, distDir, update) {
+    const filePath = path.join(distDir, `${key}.js`)
+
+    if (!update && fs.existsSync(filePath)) {
+      return
+    }
+
+    if (isString(data)) data = { default: data }
+    const content = deepDestringify(data)
+    const stringifiedContent = `export default ${objectToString(content)};`
+
+    await fs.promises.writeFile(filePath, stringifiedContent, 'utf8')
+  }
 }
 
-async function createKeyDirectoryAndFiles (key, body, distDir) {
-  const dirPath = path.join(distDir, key)
-  fs.existsSync(dirPath) || fs.mkdirSync(dirPath, { recursive: true })
-  console.log(
-    `${fs.existsSync(dirPath) ? 'Found' : 'Created'} directory: ${dirPath}`
-  )
-
-  const dirs = []
-  if (body[key] && typeof body[key] === 'object') {
-    Object.entries(body[key]).forEach(([entryKey, value]) => {
-      let childKey = entryKey
-      if (childKey.startsWith('/')) {
-        childKey = childKey.slice(1)
-        if (!childKey.length) childKey = 'main'
+async function findDiff (targetDir, distDir) {
+  const diffs = []
+
+  for (const key of keys) {
+    const targetDirPath = path.join(targetDir, key)
+    const distDirPath = path.join(distDir, key)
+
+    if (!fs.existsSync(targetDirPath)) {
+      continue
+    }
+
+    const targetFiles = await fs.promises.readdir(targetDirPath)
+    for (const file of targetFiles) {
+      if (file === 'index.js') {
+        continue // Skip comparing index.js files
       }
-      createOrUpdateFile(dirPath, childKey, value)
-      dirs.push(childKey)
-    })
+
+      const targetFilePath = path.join(targetDirPath, file)
+      const distFilePath = path.join(distDirPath, file)
+
+      if (!fs.existsSync(distFilePath)) {
+        diffs.push({
+          file: path.join(key, file),
+          diff: `File ${path.join(
+            key,
+            file
+          )} does not exist in the dist directory.`
+        })
+        continue
+      }
+
+      const targetContent = await fs.promises.readFile(
+        targetFilePath,
+        'utf8'
+      )
+      const distContent = await fs.promises.readFile(distFilePath, 'utf8')
+
+      if (targetContent !== distContent) {
+        const diff = createPatch(file, distContent, targetContent)
+        diffs.push({
+          file: path.join(key, file),
+          diff
+        })
+      }
+    }
   }
 
-  generateIndexjsFile(dirs, dirPath, key)
+  for (const key of singleFileKeys) {
+    const targetFilePath = path.join(targetDir, `${key}.js`)
+    const distFilePath = path.join(distDir, `${key}.js`)
+
+    if (!fs.existsSync(targetFilePath)) {
+      continue
+    }
+
+    if (!fs.existsSync(distFilePath)) {
+      diffs.push({
+        file: `${key}.js`,
+        diff: `File ${key}.js does not exist in the dist directory.`
+      })
+      continue
+    }
+
+    const targetContent = await fs.promises.readFile(targetFilePath, 'utf8')
+    const distContent = await fs.promises.readFile(distFilePath, 'utf8')
+
+    if (targetContent !== distContent) {
+      const diff = createPatch(key, distContent, targetContent)
+      diffs.push({
+        file: `${key}.js`,
+        diff
+      })
+    }
+  }
+
+  return diffs
+}
+
+async function generateIndexjsFile (dirs, dirPath, key) {
+  let indexContent
+  if (key === 'pages') {
+    indexContent =
+    dirs.map((d) => `import { ${d} } from './${d}';`).join('\n') + '\n' +
+    `export default {
+      ${dirs.map((d) => `'/${d === 'main' ? '' : d}': ${d},`).join('\n') + '\n'}
+    }`
+  } else if (key === 'root') {
+    indexContent =
+    dirs.map((d) => {
+      if (defaultExports.includes(d)) return `export { default as ${d} } from './${d}';`
+      else return `export * as ${d} from './${d}';`
+    }).join('\n') + '\n'
+  } else {
+    indexContent =
+    dirs.map((d) => `export * from './${d}';`).join('\n') + '\n'
+  }
+  const indexFilePath = path.join(dirPath, 'index.js')
+  await fs.promises.writeFile(indexFilePath, indexContent, 'utf8')
 }
 
-function createOrUpdateFile (dirPath, childKey, value) {
-  const filePath = path.join(dirPath, `${childKey}.js`)
+async function overrideFiles (targetDir, distDir) {
+  for (const key of keys) {
+    const targetDirPath = path.join(targetDir, key)
+    const distDirPath = path.join(distDir, key)
+
+    if (!fs.existsSync(targetDirPath)) {
+      continue
+    }
+
+    const targetFiles = await fs.promises.readdir(targetDirPath)
+    for (const file of targetFiles) {
+      const targetFilePath = path.join(targetDirPath, file)
+      const distFilePath = path.join(distDirPath, file)
+
+      await fs.promises.copyFile(targetFilePath, distFilePath)
+    }
+  }
 
-  const content = deepDestringify(value)
-  const stringifiedContent = `export const ${childKey} = ${objectToString(content)}`
+  for (const key of singleFileKeys) {
+    const targetFilePath = path.join(targetDir, `${key}.js`)
+    const distFilePath = path.join(distDir, `${key}.js`)
 
-  const fileExists = fs.existsSync(filePath)
+    if (!fs.existsSync(targetFilePath)) {
+      continue
+    }
 
-  console.log(`${fileExists ? 'Updating' : 'Creating new'} file: ${filePath}`);
-  (fileExists && fs.readFileSync(filePath, 'utf8') === content) ||
-    fs.writeFileSync(filePath, stringifiedContent)
+    await fs.promises.copyFile(targetFilePath, distFilePath)
+  }
 }
 
-function createSingleFileFolderAndFile (key, data, distDir) {
-  const filePath = path.join(distDir, `${key}.js`)
-  const content = deepDestringify(data)
-  const stringifiedContent = `export default ${objectToString(content)}`
-  const fileExists = fs.existsSync(filePath)
+async function askForConsent () {
+  const questions = [
+    {
+      type: 'confirm',
+      name: 'consent',
+      message: 'Do you want to override the files?',
+      default: false
+    }
+  ]
 
-  console.log(`${fileExists ? 'Updating' : 'Creating new'} file: ${filePath}`);
-  (fileExists && fs.readFileSync(filePath, 'utf8') === content) ||
-    fs.writeFileSync(filePath, stringifiedContent)
+  return inquirer.prompt(questions)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/cli",
-  "version": "2.11.309",
+  "version": "2.11.315",
   "description": "Fetch your Symbols configuration",
   "main": "bin/fetch.js",
   "author": "Symbols",
@@ -27,5 +27,5 @@
   "peerDependencies": {
     "@symbo.ls/convert": "latest"
   },
-  "gitHead": "22c3a3069fd57b6d539d661564f1ea9719a7f7cf"
+  "gitHead": "f7e5836ff0fad163a721cd8a823e2da1a7f346ef"
 }