@stacksjs/actions 0.43.1 → 0.44.7

package/dist/key.mjs

@@ -0,0 +1,31 @@
+import { getRandomValues } from "node:crypto";
+import { log, runCommand } from "@stacksjs/cli";
+import { setEnvValue } from "@stacksjs/utils";
+import { isFile } from "@stacksjs/storage";
+import utf8 from "crypto-js/enc-utf8";
+import base64 from "crypto-js/enc-base64";
+export async function invoke(options) {
+  await generate(options);
+}
+export async function key(options) {
+  return invoke(options);
+}
+export async function generate(options) {
+  try {
+    log.info("Setting random application key.");
+    if (!isFile(".env"))
+      await runCommand("cp .env.example .env", options);
+    await setEnvValue("APP_KEY", await generateAppKey());
+    log.success("Application key set");
+    return true;
+  } catch (error) {
+    log.error("There was an error generating your key.", error);
+    process.exit();
+  }
+}
+export async function generateAppKey() {
+  const random = getRandomValues(new Uint8Array(32));
+  const encodedWord = utf8.parse(random.toString());
+  const key2 = base64.stringify(encodedWord);
+  return `base64:${key2}`;
+}

package/dist/lint.d.ts

@@ -0,0 +1,4 @@
+import type { LintOptions } from '@stacksjs/types';
+export declare function invoke(options: LintOptions): Promise<void>;
+export declare function lint(options: LintOptions): Promise<void>;
+export declare function lintFix(options?: LintOptions): Promise<void>;

package/dist/lint.mjs

@@ -0,0 +1,28 @@
+import { log } from "@stacksjs/logging";
+import { intro, outro, runCommand } from "@stacksjs/cli";
+import { runNpmScript } from "@stacksjs/utils";
+import { ExitCode, NpmScript } from "@stacksjs/types";
+export async function invoke(options) {
+  if (options?.fix)
+    await lintFix(options);
+  else
+    await lint(options);
+}
+export async function lint(options) {
+  const perf = intro("buddy lint");
+  const result = await runCommand(NpmScript.Lint, { ...options, debug: true });
+  if (result.isErr()) {
+    outro("While running `buddy lint`, there was an issue", { startTime: perf, useSeconds: true, isError: true });
+    process.exit(ExitCode.FatalError);
+  }
+  outro("Linted", { startTime: perf, useSeconds: true });
+}
+export async function lintFix(options) {
+  log.info("Fixing lint errors...");
+  const result = await runNpmScript(NpmScript.LintFix, options);
+  if (result.isErr()) {
+    log.error("There was an error lint fixing your code.", result.error);
+    process.exit();
+  }
+  log.success("Fixed lint errors");
+}

package/dist/make.d.ts

@@ -0,0 +1,25 @@
+import type { MakeOptions } from '@stacksjs/types';
+export declare function invoke(options: MakeOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function make(options: MakeOptions): Promise<void>;
+export declare function component(options: MakeOptions): Promise<void>;
+export declare function createComponent(options: MakeOptions): Promise<void>;
+export declare function database(options: MakeOptions): Promise<void>;
+export declare function createDatabase(options: MakeOptions): Promise<void>;
+export declare function factory(options: MakeOptions): Promise<void>;
+export declare function createFactory(options: MakeOptions): Promise<void>;
+export declare function migration(options: MakeOptions): Promise<void>;
+export declare function createMigration(options: MakeOptions): Promise<void>;
+export declare function notification(options: MakeOptions): Promise<void>;
+export declare function createNotification(options: MakeOptions): Promise<void>;
+export declare function page(options: MakeOptions): Promise<void>;
+export declare function createPage(options: MakeOptions): Promise<void>;
+export declare function fx(options: MakeOptions): Promise<void>;
+export declare function createFunction(options: MakeOptions): Promise<void>;
+export declare function language(options: MakeOptions): Promise<void>;
+export declare function createLanguage(options: MakeOptions): Promise<void>;
+export declare function stack(options: MakeOptions): Promise<void>;

package/dist/make.mjs

@@ -0,0 +1,201 @@
+import { italic, log, spawn } from "@stacksjs/cli";
+import { writeTextFile } from "@stacksjs/storage";
+import { resolve } from "@stacksjs/path";
+export async function invoke(options) {
+  if (options.component)
+    await component(options);
+  if (options.database)
+    await database(options);
+  if (options.factory)
+    await factory(options);
+  if (options.function)
+    await fx(options);
+  if (options.language)
+    await language(options);
+  if (options.migration)
+    await migration(options);
+  if (options.notification)
+    await notification(options);
+  if (options.page)
+    await page(options);
+  if (options.stack)
+    await stack(options);
+}
+export async function make(options) {
+  return invoke(options);
+}
+export async function component(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your component...");
+    await createComponent(options);
+    log.success(`Created ${italic(name)} component`);
+  } catch (error) {
+    log.error("There was an error creating your component.", error);
+    process.exit();
+  }
+}
+export async function createComponent(options) {
+  const name = options.name;
+  await writeTextFile({
+    path: `./components/${name}.vue`,
+    data: `<script setup lang="ts">
+// eslint-disable-next-line no-console
+console.log('Hello World component created')
+<\/script>
+
+<template>
+  <div>
+    Some HTML block
+  </div>
+</template>
+`
+  });
+}
+export async function database(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} database...`);
+    await createDatabase(options);
+    log.success(`Created ${italic(name)} database`);
+  } catch (error) {
+    log.error("There was an error creating your database.", error);
+    process.exit();
+  }
+}
+export async function createDatabase(options) {
+  console.log("options", options);
+}
+export async function factory(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} factory...`);
+    await createDatabase(options);
+    log.success(`Created ${italic(name)} factory`);
+  } catch (error) {
+    log.error("There was an error creating your factory.", error);
+    process.exit();
+  }
+}
+export async function createFactory(options) {
+  console.log("options", options);
+}
+export async function migration(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} migration...`);
+    await createMigration(options);
+    log.success(`Created ${italic(name)} migration`);
+  } catch (error) {
+    log.error("There was an error creating your migration.", error);
+    process.exit();
+  }
+}
+export async function createMigration(options) {
+  console.log("options", options);
+}
+export async function notification(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} notification...`);
+    await createNotification(options);
+    log.success(`Created ${italic(name)} notification`);
+  } catch (error) {
+    log.error("There was an error creating your notification.", error);
+    process.exit();
+  }
+}
+export async function createNotification(options) {
+  console.log("options", options);
+}
+export async function page(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your page...");
+    createPage(options);
+    log.success(`Created ${name} page`);
+  } catch (error) {
+    log.error("There was an error creating your page.", error);
+    process.exit();
+  }
+}
+export async function createPage(options) {
+  const name = options.name;
+  await writeTextFile({
+    path: `./pages/${name}.vue`,
+    data: `<script setup lang="ts">
+// eslint-disable-next-line no-console
+console.log('Hello World page created')
+<\/script>
+
+<template>
+  <div>
+    Visit http://127.0.0.1/${name}
+  </div>
+</template>
+`
+  });
+}
+export async function fx(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your function...");
+    await createFunction(options);
+    log.success(`Created ${name} function`);
+  } catch (error) {
+    log.error("There was an error creating your function.", error);
+    process.exit();
+  }
+}
+export async function createFunction(options) {
+  const name = options.name;
+  await writeTextFile({
+    path: `./functions/${name}.ts`,
+    data: `// reactive state
+const ${name} = ref(0)
+
+// functions that mutate state and trigger updates
+function increment() {
+  ${name}.value++
+}
+
+export {
+  ${name},
+  increment,
+}
+`
+  });
+}
+export async function language(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your translation file...");
+    createLanguage(options);
+    log.success(`Created ${name} translation file`);
+  } catch (error) {
+    log.error("There was an error creating your language.", error);
+    process.exit();
+  }
+}
+export async function createLanguage(options) {
+  const name = options.name;
+  await writeTextFile({
+    path: `./lang/${name}.yml`,
+    data: `button:
+  text: Copy
+`
+  });
+}
+export async function stack(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${name} stack...`);
+    const path = resolve(process.cwd(), name);
+    await spawn(`giget stacks ${path}`);
+    log.success("Successfully scaffolded your project");
+    log.info(`cd ${path} && pnpm install`);
+  } catch (error) {
+    log.error("There was an error creating your stack.", error);
+    process.exit();
+  }
+}

package/dist/preinstall.d.ts

@@ -0,0 +1,8 @@
+import type { PreinstallOptions } from '@stacksjs/types';
+export declare function invoke(options?: PreinstallOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function preinstall(options: PreinstallOptions): Promise<void>;

package/dist/preinstall.mjs

@@ -0,0 +1,17 @@
+import { log, spawn } from "@stacksjs/cli";
+import { projectPath } from "@stacksjs/path";
+import { determineDebugMode } from "@stacksjs/config";
+export async function invoke(options) {
+  try {
+    const stdio = determineDebugMode(options) ? "inherit" : "ignore";
+    log.info("Preinstall check...");
+    await spawn("npx only-allow pnpm", { stdio, cwd: projectPath() });
+    log.success("Environment ready");
+  } catch (error) {
+    log.error("There was an error pre-installing your stack.", error);
+    process.exit();
+  }
+}
+export async function preinstall(options) {
+  return invoke(options);
+}

package/dist/prepublish.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prepublish.mjs

@@ -0,0 +1,11 @@
+import { log } from "@stacksjs/logging";
+import { runtimePath } from "@stacksjs/path";
+import { runNpmScript } from "@stacksjs/utils";
+import { NpmScript } from "@stacksjs/types";
+log.info("Running prepublish command...");
+const result = await runNpmScript(NpmScript.BuildStacks, { debug: true, cwd: runtimePath() });
+if (result.isErr()) {
+  log.error("There was an error while prepublishing your stack, during the process of building Stacks.", result.error);
+  process.exit();
+}
+log.success("Prepublishing completed");

package/dist/release.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/release.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { frameworkPath } from "@stacksjs/path";
+import { runAction } from "@stacksjs/actions";
+import { runNpmScript } from "@stacksjs/utils";
+import { NpmScript } from "@stacksjs/types";
+import { log } from "@stacksjs/cli";
+let result = await runAction("generate-package-json");
+if (result.isErr()) {
+  log.error("There was an error while releasing your stack, during the process of fixing your lint errors.", result.error);
+  process.exit();
+}
+result = await runNpmScript(NpmScript.LintFix, { debug: true, cwd: frameworkPath() });
+if (result.isErr()) {
+  log.error("There was an error while releasing your stack, during the process of fixing your lint errors.", result.error);
+  process.exit();
+}
+result = await runNpmScript(NpmScript.Release, { debug: true, cwd: frameworkPath() });
+if (result.isErr()) {
+  log.error("There was an error while releasing your stack.", result.error);
+  process.exit();
+}

package/dist/test.d.ts

@@ -0,0 +1,11 @@
+import type { TestOptions } from '@stacksjs/types';
+export declare function invoke(options: TestOptions): Promise<void>;
+export declare function testUi(options: TestOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function test(options: TestOptions): Promise<void>;
+export declare function typecheck(options: TestOptions): Promise<void>;
+export declare function testCoverageReport(options: TestOptions): Promise<void>;

package/dist/test.mjs

@@ -0,0 +1,43 @@
+import { NpmScript } from "@stacksjs/types";
+import { intro, outro, runCommand } from "@stacksjs/cli";
+import { projectPath } from "@stacksjs/path";
+export async function invoke(options) {
+  const perf = intro("buddy test");
+  const result = await runCommand(NpmScript.Test, { ...options, debug: true, cwd: projectPath() });
+  if (result.isErr()) {
+    outro("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+  outro("Finished running tests", { startTime: perf, useSeconds: true });
+}
+export async function testUi(options) {
+  const perf = intro("buddy test:ui");
+  const result = await runCommand(NpmScript.TestUi, { ...options, debug: true });
+  if (result.isErr()) {
+    outro("While running `buddy test:ui`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+}
+export async function test(options) {
+  return invoke(options);
+}
+export async function typecheck(options) {
+  const perf = intro("buddy test:types");
+  const result = await runCommand(NpmScript.TestTypes, options);
+  if (result.isErr()) {
+    outro("While running `buddy test:types`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+  outro("Finished typecheck", { startTime: perf, useSeconds: true });
+  process.exit();
+}
+export async function testCoverageReport(options) {
+  const perf = intro("buddy test:coverage");
+  const result = await runCommand(NpmScript.TestCoverage, options);
+  if (result.isErr()) {
+    outro("While running `buddy test:coverage`, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+  outro("Generated the test coverage report", { startTime: perf, useSeconds: true });
+  process.exit();
+}

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import { type TypesOptions } from '@stacksjs/types';
+export declare function invoke(options?: TypesOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function types(options: TypesOptions): Promise<void>;

package/dist/types.mjs

@@ -0,0 +1,14 @@
+import { log } from "@stacksjs/logging";
+import { runNpmScript } from "@stacksjs/utils";
+import { NpmScript } from "@stacksjs/types";
+export async function invoke(options) {
+  const results = await runNpmScript(NpmScript.TypesFix, options);
+  if (results.isErr()) {
+    log.error("There was an error fixing your types.", results.error);
+    process.exit();
+  }
+  log.success("Types are set");
+}
+export async function types(options) {
+  return invoke(options);
+}

package/dist/update.d.ts

@@ -0,0 +1,14 @@
+import type { UpdateOptions } from '@stacksjs/types';
+export declare function invoke(options?: UpdateOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function update(options: UpdateOptions): Promise<void>;
+export declare function checkForUncommittedChanges(path: string | undefined, options: UpdateOptions): Promise<void>;
+export declare function updateFramework(options: UpdateOptions): Promise<void>;
+export declare function downloadFrameworkUpdate(options: UpdateOptions): Promise<void>;
+export declare function updateDependencies(options: UpdateOptions): Promise<void>;
+export declare function updatePackageManager(options: UpdateOptions): Promise<void>;
+export declare function updateNode(options: UpdateOptions): Promise<void>;

package/dist/update.mjs

@@ -0,0 +1,100 @@
+import { intro, log, outro, prompts, runCommand, spawn } from "@stacksjs/cli";
+import storage from "@stacksjs/storage";
+import { loop } from "@stacksjs/utils";
+import { determineDebugMode } from "@stacksjs/config";
+import { frameworkPath, projectPath } from "@stacksjs/path";
+import { ExitCode, NpmScript } from "@stacksjs/types";
+export async function invoke(options) {
+  if (options?.framework || options?.all)
+    await updateFramework(options);
+  if (options?.dependencies || options?.all)
+    await updateDependencies(options);
+  if (options?.packageManager || options?.all)
+    await updatePackageManager(options);
+  if (options?.node || options?.all)
+    await updateNode(options);
+  else
+    process.exit(ExitCode.InvalidArgument);
+}
+export async function update(options) {
+  return await invoke(options);
+}
+export async function checkForUncommittedChanges(path = "./.stacks", options) {
+  try {
+    const stdio = determineDebugMode(options) ? "inherit" : "ignore";
+    await spawn(`git diff --quiet HEAD -- ${path}`, { stdio, cwd: projectPath() });
+  } catch (error) {
+    if (error.status === 1) {
+      if (!options?.force) {
+        const answer = await prompts.confirm({
+          type: "select",
+          name: "framework-update",
+          message: "We detected there are uncommitted in the ./stacks folder. Do you want to overwrite those?"
+        });
+        if (!answer) {
+          log.info("Aborted. Stacks did not update itself.");
+          log.info("Note: if you commit your changes and replay the update, you can see what changed.");
+          process.exit(ExitCode.Success);
+        }
+      }
+    }
+  }
+}
+export async function updateFramework(options) {
+  const perf = intro("buddy update:framework");
+  await checkForUncommittedChanges("./.stacks", options);
+  await downloadFrameworkUpdate(options);
+  log.info("Updating framework...");
+  const exclude = ["functions/package.json", "components/vue/package.json", "components/web/package.json", "auto-imports.d.ts", "components.d.ts", "dist"];
+  await storage.deleteFiles(frameworkPath(), exclude);
+  loop(5, async () => {
+    await storage.deleteEmptyFolders(frameworkPath());
+  });
+  await storage.copyFolder(frameworkPath(), projectPath("./updates/.stacks"), exclude);
+  if (determineDebugMode(options))
+    log.info("Cleanup...");
+  await storage.deleteFolder(projectPath("updates"));
+  outro("Framework updated", { startTime: perf, useSeconds: true });
+  process.exit();
+}
+export async function downloadFrameworkUpdate(options) {
+  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);
+  const version = (await storage.readJsonFile(projectPath(`${tempFolderName}/.stacks/version`))).data;
+  log.success("Your framework updated correctly to version: ", version);
+}
+export async function updateDependencies(options) {
+  const perf = intro("buddy update:dependencies");
+  const result = await runCommand(NpmScript.UpdateDependencies, options);
+  if (result.isErr()) {
+    outro("While running the update:dependencies command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+  outro("Freshly updated your dependencies.", { startTime: perf, useSeconds: true });
+  process.exit();
+}
+export async function updatePackageManager(options) {
+  const perf = intro("buddy update:package-manager");
+  const version = options?.version || "latest";
+  const result = await runCommand(`corepack prepare pnpm@${version} --activate`, options);
+  if (result.isErr()) {
+    outro("While running the update:package-manager command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+  outro(`Updated to version: ${version}`, { startTime: perf, useSeconds: true });
+  process.exit();
+}
+export async function updateNode(options) {
+  const perf = intro("buddy update:node");
+  const result = await runCommand(NpmScript.UpdateNode, options);
+  if (result.isErr()) {
+    outro("While running the update:node command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+    process.exit();
+  }
+  outro(`Updated your project's Node.js version to: ${process.version}`, { startTime: perf, useSeconds: true });
+  process.exit();
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/actions",
   "type": "module",
-  "version": "0.43.1",
-  "packageManager": "pnpm@7.17.1",
+  "version": "0.44.7",
+  "packageManager": "pnpm@7.18.2",
   "description": "The Stacks actions.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -37,23 +37,27 @@
   ],
   "engines": {
     "node": ">=v18.12.1",
-    "pnpm": ">=7.17.1"
+    "pnpm": ">=7.18.2"
   },
   "peerDependencies": {
     "markdown-it": "^13.0.1",
-    "vue-component-meta": "^1.0.10",
-    "@stacksjs/config": "0.43.1",
-    "@stacksjs/path": "0.43.1",
-    "@stacksjs/storage": "0.43.1",
-    "@stacksjs/strings": "0.43.1",
-    "@stacksjs/types": "0.43.1",
-    "@stacksjs/utils": "0.43.1",
-    "@stacksjs/x-ray": "0.43.1"
+    "vue-component-meta": "^1.0.13",
+    "@stacksjs/cli": "0.44.7",
+    "@stacksjs/config": "0.44.7",
+    "@stacksjs/logging": "0.44.7",
+    "@stacksjs/path": "0.44.7",
+    "@stacksjs/storage": "0.44.7",
+    "@stacksjs/types": "0.44.7",
+    "@stacksjs/utils": "0.44.7"
+  },
+  "dependencies": {
+    "esno": "^0.16.3",
+    "@stacksjs/strings": "0.44.7"
   },
   "devDependencies": {
     "mkdist": "^1.0.0",
-    "typescript": "^4.9.3",
-    "@stacksjs/testing": "0.43.1"
+    "typescript": "^4.9.4",
+    "@stacksjs/testing": "0.44.7"
   },
   "scripts": {
     "build": "mkdist -d",