stacks 0.58.41 → 0.58.44

package/core/actions/dist/src/build/core.js

@@ -2,24 +2,20 @@
 // src/build/core.ts
 import process from "process";
 import {glob} from "@stacksjs/storage";
+import {dim, italic, log} from "@stacksjs/cli";
 import {corePath} from "@stacksjs/path";
 import {ExitCode} from "@stacksjs/types";
-import {dim, italic, log, runCommand} from "@stacksjs/cli";
+var {$ } = globalThis.Bun;
 log.info("Building core packages");
-var dirs = await glob([corePath("*")], { onlyDirectories: true });
+var dirs = (await glob([corePath("*")], { onlyDirectories: true })).sort();
 if (dirs.length === 0) {
   log.info("No core packages found");
   process.exit(ExitCode.FatalError);
 }
-dirs.forEach(async (folder) => {
-  log.info("\uD83C\uDFD7\uFE0F  Building...");
-  log.info(`\uD83D\uDCE6 ${italic(dim(folder))}`);
-  const result = await runCommand("bun --bun run build", {
-    cwd: folder
-  });
-  if (result.isErr()) {
-    log.error(`Failed to build ${italic(folder)}`);
-    process.exit(ExitCode.FatalError);
-  }
-  log.success("\u2705 Build complete");
-});
+for (const folder of dirs) {
+  log.info(`\uD83C\uDFD7\uFE0F  Building ${italic(dim(folder))}`);
+  $.cwd(folder);
+  await $`bun run build`;
+  log.success(`${italic(dim(folder))} built`);
+  console.log(``);
+}

package/core/actions/dist/src/lint/index.js

@@ -1,21 +1,17 @@
 // @bun
 // src/lint/index.ts
 import process from "process";
-import {runCommands} from "@stacksjs/cli";
-import {projectPath} from "@stacksjs/path";
 import {ExitCode} from "@stacksjs/types";
 import {NpmScript} from "@stacksjs/enums";
-async function lintAction() {
-  const result = await runCommands([
-    NpmScript.Lint,
-    NpmScript.LintPackageJson
-  ], { cwd: projectPath(), verbose: true });
-  if (Array.isArray(result)) {
-    if (result.map((r) => r.isErr()).includes(true))
-      process.exit(ExitCode.FatalError);
-  }
-  process.exit(ExitCode.Success);
+import {log, runCommands} from "@stacksjs/cli";
+import {projectPath} from "@stacksjs/path";
+log.info("Ensuring Code Style...");
+var result = await runCommands([
+  NpmScript.Lint,
+  NpmScript.LintPackageJson
+], { cwd: projectPath() });
+if (Array.isArray(result)) {
+  if (result.map((r) => r.isErr()).includes(true))
+    process.exit(ExitCode.FatalError);
 }
-export {
-  lintAction as default
-};
+log.success("Linted");

package/core/actions/dist/src/upgrade/index.js

@@ -1 +1,63 @@
 // @bun
+// src/helpers/utils.ts
+import * as storage from "@stacksjs/storage";
+import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {log} from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import {err, handleError} from "@stacksjs/error-handling";
+var parseOptions = function(options) {
+  if (!options)
+    return "";
+  const parsedOptions = Object.entries(options).map(([key, value]) => {
+    if (key.length === 1)
+      return `-${key}=${value}`;
+    if (typeof value === "boolean" && value)
+      return `--${key}`;
+    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
+  });
+  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
+};
+async function runAction(action, options) {
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  const opts = parseOptions(options);
+  const path = p.relativeActionsPath(`${action}.ts`);
+  const cmd = `bun --bun ${`${path} ${opts}`}`;
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  if (options?.verbose) {
+    log.debug("Running cmd:", underline(italic(cmd)));
+    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
+    log.debug("with action options of:", o);
+  }
+  return await runCommand(cmd, o);
+}
+async function runActions(actions, options) {
+  if (!actions.length)
+    return err("No actions were specified");
+  for (const action of actions) {
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`);
+  }
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
+  return await runCommands(commands, options);
+}
+function hasAction(action) {
+  if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))
+    return true;
+  return storage.isFile(p.actionsPath(`${action}.ts`));
+}
+// src/upgrade/index.ts
+import process from "process";
+import {ExitCode, parseArgs} from "@stacksjs/cli";
+import {Action} from "@stacksjs/enums";
+var options = parseArgs();
+if (options?.framework || options?.all)
+  await updateFramework(options);
+if (options?.dependencies || options?.all)
+  await updateDependencies(options);
+if (options?.bun || options?.all)
+  await runAction(Action.UpgradeBun, options);
+process.exit(ExitCode.InvalidArgument);

package/core/actions/dist/src/upgrade.js

@@ -6,29 +6,34 @@ import {log} from "@stacksjs/logging";
 import {projectPath} from "@stacksjs/path";
 import * as storage from "@stacksjs/storage";
 // package.json
-var version = "0.58.41";
+var version = "0.58.44";
 
 // src/upgrade.ts
-function checkForUncommittedChanges(options) {
+function checkForUncommittedChanges(options2) {
   try {
   } catch (error) {
     if (error.status === 1) {
-      if (!options?.force) {
+      if (!options2?.force) {
       }
     }
   }
 }
-async function downloadFrameworkUpdate(options) {
+async function downloadFrameworkUpdate(options2) {
   const tempFolderName = "updates";
   const tempUpdatePath = projectPath(tempFolderName);
   if (storage.doesFolderExist(tempUpdatePath))
     await deleteFolder(tempUpdatePath);
   log.info("Downloading framework updates...");
-  await runCommand(`giget stacks ${tempFolderName}`, options);
+  await runCommand(`giget stacks ${tempFolderName}`, options2);
   log.success(`Your framework updated correctly to version: v${version}`);
 }
 async function updateDependencies() {
   const perf = await intro("buddy upgrade:dependencies");
+  const result = await runCommand(NpmScript.UpgradeDependencies, options);
+  if (result.isErr()) {
+    outro("While running the upgrade:dependencies command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+    process.exit();
+  }
   await outro("Freshly updated your dependencies.", { startTime: perf, useSeconds: true });
   process.exit();
 }

package/core/actions/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/actions",
   "type": "module",
-  "version": "0.58.41",
+  "version": "0.58.44",
   "description": "The Stacks actions.",
   "author": "Chris Breuer",
   "license": "MIT",

package/core/actions/src/build/cli.ts

@@ -0,0 +1,7 @@
+import { log } from '@stacksjs/cli'
+import { buddyPath } from '@stacksjs/path'
+import { $ } from 'bun'
+
+log.info('Building CLI')
+
+await $`bun ${buddyPath('compile.ts')}`

package/core/actions/src/build/core.ts

@@ -1,66 +1,34 @@
 import process from 'node:process'
 import { glob } from '@stacksjs/storage'
+import { dim, italic, log } from '@stacksjs/cli'
 import { corePath } from '@stacksjs/path'
 import { ExitCode } from '@stacksjs/types'
-import { dim, italic, log, runCommand } from '@stacksjs/cli'
+import { $ } from 'bun'
 
 log.info('Building core packages')
 
-const dirs = (await glob([corePath('*')], { onlyDirectories: true }))
+const dirs = (await glob([corePath('*')], { onlyDirectories: true })).sort()
 
 if (dirs.length === 0) {
   log.info('No core packages found')
   process.exit(ExitCode.FatalError)
 }
 
-dirs.forEach(async (folder) => {
-  log.info('🏗️  Building...')
-  log.info(`📦 ${italic(dim(folder))}`)
+for (const folder of dirs) {
+  log.info(`🏗️  Building ${italic(dim(folder))}`)
 
-  const result = await runCommand('bun --bun run build', {
-    cwd: folder,
-  })
+  $.cwd(folder)
+  await $`bun run build`
+  log.success(`${italic(dim(folder))} built`)
 
-  if (result.isErr()) {
-    log.error(`Failed to build ${italic(folder)}`)
-    process.exit(ExitCode.FatalError)
-  }
-
-  log.success('✅ Build complete')
-})
-
-// run the tsc command
-// log.info('Generating type definitions...')
-
-// const tscResult = await runCommand('bun --bun tsc', projectPath())
-
-// if (tscResult.isErr()) {
-//   log.error(tscResult.error)
-//   process.exit(ExitCode.FatalError)
-// }
+  // eslint-disable-next-line no-console
+  console.log(``)
+}
 
-// log.success('Generated type definitions')
+// dirs.forEach(async (folder) => {
+//   log.info(`🏗️  Building ${italic(dim(folder))}`)
 
-// move type definitions to the dist folder
-// log.info('Moving type definitions to dist folder...')
-// const moveResult = await runCommand('bun --bun move-dts-files.ts', {
-//   cwd: import.meta.dir
+//   $.cwd(folder)
+//   const text = await $`bun run build`.text()
+//   console.log(text)
 // })
-
-// if (moveResult.isErr()) {
-//   log.error(moveResult.error)
-//   process.exit(ExitCode.FatalError)
-// }
-
-// log.success('Moved type definitions to dist folder')
-
-// move core/*/dist/src/* to core/*/dist/*
-// log.info('Moving built source files to dist folder...')
-// const moveSrcResult = await runCommand('bun --bun move-built-src-files.ts', import.meta.dir)
-
-// if (moveSrcResult.isErr()) {
-//   log.error(moveSrcResult.error)
-//   process.exit(ExitCode.FatalError)
-// }
-
-// log.success('Moved built source files in the dist folder')

package/core/actions/src/dev/api.ts

@@ -12,7 +12,7 @@ serve({
   port: config.app.ports?.api, // defaults to 3999
 })
 
-// we need this proxied by vite
+// the reason we start a Vite dev server next is because we need the Bun server proxied by vite
 await runCommand(`bunx vite --config ${p.vitePath('src/api.ts')}`, {
   // ...options,
   cwd: p.frameworkPath(),

package/core/actions/src/lint/index.ts

@@ -1,19 +1,27 @@
 import process from 'node:process'
-import { runCommands } from '@stacksjs/cli'
-import { projectPath } from '@stacksjs/path'
 import { ExitCode } from '@stacksjs/types'
 import { NpmScript } from '@stacksjs/enums'
+import { log, runCommands } from '@stacksjs/cli'
+import { projectPath } from '@stacksjs/path'
+
+// import { $ } from 'bun'
 
-export default async function lintAction() {
-  const result = await runCommands([
-    NpmScript.Lint,
-    NpmScript.LintPackageJson,
-  ], { cwd: projectPath(), verbose: true })
+log.info('Ensuring Code Style...')
 
-  if (Array.isArray(result)) {
-    if (result.map(r => r.isErr()).includes(true))
-      process.exit(ExitCode.FatalError)
-  }
+// TODO: somehow, we currently cannot trigger bunx using $`` syntax
+// $.cwd(projectPath())
 
-  process.exit(ExitCode.Success)
+// await $`${NpmScript.Lint}`
+// await $`${NpmScript.LintPackageJson}`
+
+const result = await runCommands([
+  NpmScript.Lint,
+  NpmScript.LintPackageJson,
+], { cwd: projectPath() })
+
+if (Array.isArray(result)) {
+  if (result.map(r => r.isErr()).includes(true))
+    process.exit(ExitCode.FatalError)
 }
+
+log.success('Linted')

package/core/actions/src/upgrade/index.ts

@@ -1,25 +1,21 @@
-// import { ExitCode, parseArgs } from '@stacksjs/cli'
-// import { Action } from '@stacksjs/enums'
-// import { runAction } from '../helpers'
-//
-// const options = parseArgs()
+import process from 'node:process'
+import { ExitCode, parseArgs } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+import { runAction } from '../helpers'
+
+const options = parseArgs()
 
 // run all the upgrade actions
-// if (options?.framework || options?.all)
-//   await updateFramework(options)
+if (options?.framework || options?.all)
+  await updateFramework(options)
+
+if (options?.dependencies || options?.all)
+  await updateDependencies(options)
 
-// if (options?.dependencies || options?.all)
-//   await updateDependencies(options)
+if (options?.bun || options?.all)
+  await runAction(Action.UpgradeBun, options)
 
-// if (options?.packageManager || options?.all)
-//   await runAction(Action.UpgradePackageManager, options)
-//
-// if (options?.node || options?.all)
-//   await runAction(Action.UpgradeNode, options)
-//
-// else
-//   process.exit(ExitCode.InvalidArgument)
+process.exit(ExitCode.InvalidArgument)
 
-//   // TODO: also update CI files & configurations, and other files, possibly
-//   // we want this to be smart enough to update only if files that have been updated
-//   // TODO: this script should trigger regeneration of auto-imports.d.ts & components.d.ts
+// TODO: also update CI files & configurations, and other files, possibly (taze?)
+// we want this to be smart enough to update only if files that have been updated

package/core/actions/src/upgrade.ts

@@ -53,12 +53,12 @@ export async function downloadFrameworkUpdate(options: UpgradeOptions) {
 // export async function updateDependencies(options: UpgradeOptions) {
 export async function updateDependencies() {
   const perf = await intro('buddy upgrade:dependencies')
-  // const result = await runCommand(NpmScript.UpgradeDependencies, options)
+  const result = await runCommand(NpmScript.UpgradeDependencies, options)
 
-  // if (result.isErr()) {
-  //   outro('While running the upgrade:dependencies command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
-  //   process.exit()
-  // }
+  if (result.isErr()) {
+    outro('While running the upgrade:dependencies command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+    process.exit()
+  }
 
   await outro('Freshly updated your dependencies.', { startTime: perf, useSeconds: true })
   process.exit()