@stacksjs/actions 0.59.11 → 0.61.0

package/dist/index.js

@@ -0,0 +1,676 @@
+// @bun
+// src/helpers/utils.ts
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
+import {err} from "@stacksjs/error-handling";
+import {log} from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import {glob} from "@stacksjs/storage";
+var {Glob } = globalThis.Bun;
+async function runAction(action, options) {
+  const glob2 = new Glob("**/*.ts");
+  const scanOptions = { cwd: p.userActionsPath(), onlyFiles: true };
+  for await (const file of glob2.scan(scanOptions)) {
+    log.debug("file", file);
+    if (file === `${action}.ts` || file.endsWith(`${action}.ts`))
+      return (await import(p.userActionsPath(file))).default.handle();
+    const a = await import(p.userActionsPath(file));
+    if (a.name === action)
+      return await a.handle();
+  }
+  const opts = buddyOptions();
+  const path = p.relativeActionsPath(`src/${action}.ts`);
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  return await runCommand(cmd, optionsWithCwd);
+}
+async function runActions(actions, options) {
+  log.debug("runActions:", actions, options);
+  if (!actions.length)
+    return err("No actions were specified");
+  for (const action of actions) {
+    log.debug(`running action "${action}"`);
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`);
+  }
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`);
+  log.debug("commands:", commands);
+  return await runCommands(commands, o);
+}
+function hasAction(action) {
+  const userActionPatterns = [
+    `${action}.ts`,
+    `${action}`,
+    `Dashboard/${action}.ts`,
+    `Dashboard/${action}`,
+    `Buddy/${action}.ts`,
+    `Buddy/${action}`
+  ];
+  const actionPatterns = [`src/${action}.ts`, `src/${action}`, `${action}.ts`, `${action}`];
+  const userActionFiles = glob.sync(userActionPatterns.map((pattern) => p.userActionsPath(pattern)));
+  const actionFiles = glob.sync(actionPatterns.map((pattern) => p.actionsPath(pattern)));
+  return userActionFiles.length > 0 || actionFiles.length > 0;
+}
+
+// src/dev/index.ts
+import {Action} from "@stacksjs/enums";
+import {log as log2} from "@stacksjs/logging";
+async function runDevServer(options) {
+  log2.info("Starting your Frontend Engine...");
+  await runAction(Action.Dev, options);
+}
+async function runFrontendDevServer(options) {
+  log2.info("Starting your UI Engine...");
+  await runAction(Action.Dev, options);
+}
+async function runBackendDevServer(options) {
+  runApiDevServer(options);
+}
+async function runApiDevServer(options) {
+  log2.info("Starting your API...");
+  await runAction(Action.DevApi, options);
+}
+async function runComponentsDevServer(options) {
+  log2.info("Starting your Library Engine...");
+  await runAction(Action.DevComponents, options);
+}
+async function runDashboardDevServer(options) {
+  log2.info("Starting your Dashboard...");
+  await runAction(Action.DevDashboard, options);
+}
+async function runSystemTrayDevServer(options) {
+  log2.info("Starting your System Tray...");
+  await runAction(Action.DevSystemTray, options);
+}
+async function runDesktopDevServer(options) {
+  log2.info("Starting your Desktop Engine...");
+  await runAction(Action.DevDesktop, options);
+}
+async function runDocsDevServer(options) {
+  log2.info("Starting your Docs Engine...");
+  await runAction(Action.DevDocs, options);
+}
+
+// src/helpers/vscode-custom-data.ts
+import {log as log3} from "@stacksjs/logging";
+import {customElementsDataPath} from "@stacksjs/path";
+import {writeTextFile} from "@stacksjs/storage";
+
+// ../../../../config/library.ts
+var library_default = {
+  name: "hello-world",
+  owner: "@stacksjs",
+  repository: "stacksjs/stacks",
+  license: "MIT",
+  author: "Chris Breuer",
+  contributors: ["Chris Breuer <chris@stacksjs.org>"],
+  defaultLanguage: "en",
+  releaseable: true,
+  vueComponents: {
+    name: "hello-world-vue",
+    description: "Your Vue component library description",
+    keywords: ["component", "library", "vue", "vite", "typescript", "javascript"],
+    tags: [
+      {
+        name: ["HelloWorld", "AppHelloWorld"],
+        description: "The Hello World custom element, built via this framework.",
+        attributes: [
+          {
+            name: "greeting",
+            description: "The greeting."
+          }
+        ]
+      }
+    ]
+  },
+  webComponents: {
+    name: "hello-world-elements",
+    description: "Your framework agnostic web component library description.",
+    keywords: ["custom-elements", "web-components", "library", "framework-agnostic", "typescript", "javascript"],
+    tags: [
+      {
+        name: ["HelloWorld", "AppHelloWorld"],
+        description: "The Hello World custom element, built via this framework.",
+        attributes: [
+          {
+            name: "greeting",
+            description: "The greeting."
+          }
+        ]
+      }
+    ]
+  },
+  functions: {
+    name: "hello-world-fx",
+    description: "Your function library description.",
+    keywords: ["functions", "composables", "library", "typescript", "javascript"],
+    shouldGenerateSourcemap: false,
+    files: ["counter", "dark"]
+  }
+};
+
+// src/helpers/vscode-custom-data.ts
+async function generateVsCodeCustomData() {
+  try {
+    log3.info("Generating custom-elements.json...");
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+    log3.success("Generated custom-elements.json for IDEs.");
+  } catch (err2) {
+    log3.error("There was an error generating the custom-elements.json file.", err2);
+  }
+}
+async function generateWebTypes() {
+  log3.info("Generating web-types.json...");
+  log3.info("This feature is not yet implemented.");
+}
+var generateComponentInfoData = function() {
+  const componentsData = JSON.stringify(library_default.vueComponents?.tags);
+  return `{
+  "version": 1.1,
+  "tags": ${componentsData}
+}
+`;
+};
+
+// src/generate/index.ts
+import process from "process";
+import {runCommand as runCommand2} from "@stacksjs/cli";
+import {Action as Action2, NpmScript} from "@stacksjs/enums";
+import {log as log4} from "@stacksjs/logging";
+import {frameworkPath, projectPath as projectPath2} from "@stacksjs/path";
+import {runNpmScript} from "@stacksjs/utils";
+async function invoke(options) {
+  if (options?.types)
+    await generateTypes(options);
+  else if (options?.entries)
+    await generateLibEntries(options);
+  else if (options?.webTypes)
+    await generateWebTypes2(options);
+  else if (options?.customData)
+    await generateVsCodeCustomData2(options);
+  else if (options?.ideHelpers)
+    await generateIdeHelpers(options);
+  else if (options?.componentMeta)
+    await generateComponentMeta(options);
+  else if (options?.coreSymlink)
+    await generateCoreSymlink();
+}
+function generate(options) {
+  return invoke(options);
+}
+async function generateLibEntries(options) {
+  const result = await runAction(Action2.GenerateLibraryEntries, {
+    ...options,
+    cwd: projectPath2()
+  });
+  if (result.isErr()) {
+    log4.error("There was an error generating your library entry points", result.error);
+    process.exit();
+  }
+  log4.success("Library entry points generated successfully");
+}
+async function generateWebTypes2(options) {
+  const result = await runNpmScript(NpmScript.GenerateWebTypes, options);
+  if (result.isErr()) {
+    log4.error("There was an error generating the web-types.json file.", result.error);
+    process.exit();
+  }
+  log4.success("Successfully generated the web-types.json file");
+}
+async function generateVsCodeCustomData2(options) {
+  const result = await generateVsCodeCustomData();
+  if (result.isErr()) {
+    log4.error("There was an error generating the custom-elements.json file.", result.error);
+    process.exit();
+  }
+  await runAction(Action2.LintFix, { verbose: true });
+  log4.success("Successfully generated the custom-elements.json file");
+}
+async function generateIdeHelpers(options) {
+  const result = await runNpmScript(NpmScript.GenerateIdeHelpers, options);
+  if (result.isErr()) {
+    log4.error("There was an error generating IDE helpers.", result.error);
+    process.exit();
+  }
+  await runAction(Action2.LintFix, { verbose: true });
+  log4.success("Successfully generated IDE helpers");
+}
+async function generateComponentMeta(options) {
+  const result = await generateVsCodeCustomData();
+  if (result.isErr()) {
+    log4.error("There was an error generating your component meta information.", result.error);
+    process.exit();
+  }
+  await runAction(Action2.LintFix, { verbose: true });
+  log4.success("Successfully generated component meta information");
+}
+async function generateTypes(options) {
+  const result = await runNpmScript(NpmScript.GenerateTypes, {
+    cwd: frameworkPath(),
+    ...options
+  });
+  if (result.isErr()) {
+    log4.error("There was an error generating your types.", result.error);
+    process.exit();
+  }
+  log4.success("Types were generated successfully");
+}
+function generatePkgxConfig() {
+  log4.success("Successfully generated `./pkgx.yaml` based on your config");
+}
+async function generateSeeder() {
+}
+async function generateCoreSymlink() {
+  await runCommand2(`ln -s ${frameworkPath()} ${projectPath2(".stacks")}`);
+}
+
+// src/add.ts
+import {installPackage} from "@stacksjs/cli";
+async function invoke2(options) {
+  if (options?.table)
+    await addTable();
+  if (options?.calendar)
+    await addCalendar();
+}
+async function add(options) {
+  return invoke2(options);
+}
+async function addTable() {
+  await installPackage("@stacksjs/table");
+}
+async function addCalendar() {
+  await installPackage("@stacksjs/calendar");
+}
+async function installPackages(names) {
+  for (const name of names)
+    await installPackage(name);
+}
+
+// src/commit.ts
+import {NpmScript as NpmScript2} from "@stacksjs/enums";
+import {log as log5} from "@stacksjs/logging";
+import {runNpmScript as runNpmScript2} from "@stacksjs/utils";
+async function invoke3(options) {
+  log5.info("Committing...");
+  await runNpmScript2(NpmScript2.Commit, options);
+  log5.success("Committed");
+}
+async function commit(options) {
+  return invoke3(options);
+}
+
+// src/make.ts
+import process2 from "process";
+import {italic} from "@stacksjs/cli";
+import {log as log6} from "@stacksjs/logging";
+import {frameworkPath as frameworkPath2, path as p2, resolve} from "@stacksjs/path";
+import {createFolder, doesFolderExist, writeTextFile as writeTextFile2} from "@stacksjs/storage";
+async function invoke4(options) {
+  if (options.component)
+    await makeComponent(options);
+  if (options.database)
+    makeDatabase(options);
+  if (options.function)
+    await makeFunction(options);
+  if (options.language)
+    await makeLanguage(options);
+  if (options.notification)
+    await makeNotification(options);
+  if (options.page)
+    await makePage(options);
+  if (options.stack)
+    makeStack(options);
+}
+async function make(options) {
+  return invoke4(options);
+}
+async function makeAction(options) {
+  try {
+    const name = options.name;
+    log6.info("Creating your action...");
+    await createAction(options);
+    log6.success(`Created ${italic(name)} action`);
+  } catch (error) {
+    log6.error("There was an error creating your action", error);
+    process2.exit();
+  }
+}
+async function makeComponent(options) {
+  try {
+    const name = options.name;
+    log6.info("Creating your component...");
+    await createComponent(options);
+    log6.success(`Created ${italic(name)} component`);
+  } catch (error) {
+    log6.error("There was an error creating your component", error);
+    process2.exit();
+  }
+}
+async function createAction(options) {
+  const name = options.name;
+  await writeTextFile2({
+    path: p2.userActionsPath(`${name}.ts`),
+    data: `import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: '${name}',
+  description: '${name} action',
+
+  handle() {
+    return 'Hello World action'
+  },
+})
+`
+  });
+}
+async function createComponent(options) {
+  const name = options.name;
+  await writeTextFile2({
+    path: p2.userComponentsPath(`${name}.stx`),
+    data: `<script setup lang="ts">
+console.log('Hello World component created')
+</script>
+
+<template>
+  <div>
+    Some HTML block
+  </div>
+</template>
+`
+  });
+}
+function makeDatabase(options) {
+  try {
+    const name = options.name;
+    log6.info(`Creating your ${italic(name)} database...`);
+    createDatabase(options);
+    log6.success(`Created ${italic(name)} database`);
+  } catch (error) {
+    log6.error("There was an error creating your database", error);
+    process2.exit();
+  }
+}
+function createDatabase(options) {
+  console.log("createDatabase options", options);
+}
+function factory(options) {
+  try {
+    const name = options.name;
+    log6.info(`Creating your ${italic(name)} factory...`);
+    createDatabase(options);
+    log6.success(`Created ${italic(name)} factory`);
+  } catch (error) {
+    log6.error("There was an error creating your factory", error);
+    process2.exit();
+  }
+}
+function createFactory(options) {
+  console.log("options", options);
+}
+async function makeNotification(options) {
+  try {
+    const name = options.name;
+    log6.info(`Creating your ${italic(name)} notification...`);
+    await createNotification(options);
+    log6.success(`Created ${italic(name)} notification`);
+  } catch (error) {
+    log6.error("There was an error creating your notification", error);
+    process2.exit();
+  }
+}
+async function makePage(options) {
+  try {
+    const name = options.name;
+    log6.info("Creating your page...");
+    await createPage(options);
+    log6.success(`Created ${name} page`);
+  } catch (error) {
+    log6.error("There was an error creating your page", error);
+    process2.exit();
+  }
+}
+async function createPage(options) {
+  const name = options.name;
+  await writeTextFile2({
+    path: p2.userViewsPath(`${name}.stx`),
+    data: `<script setup lang="ts">
+console.log('Hello World page created')
+</script>
+
+<template>
+  <div>
+    Visit http://127.0.0.1/${name}
+  </div>
+</template>
+`
+  });
+}
+async function makeFunction(options) {
+  try {
+    const name = options.name;
+    log6.info("Creating your function...");
+    await createFunction(options);
+    log6.success(`Created ${name} function`);
+  } catch (error) {
+    log6.error("There was an error creating your function", error);
+    process2.exit();
+  }
+}
+async function createFunction(options) {
+  const name = options.name;
+  await writeTextFile2({
+    path: p2.userFunctionsPath(`${name}.ts`),
+    data: `// reactive state
+const ${name} = ref(0)
+
+// functions that mutate state and trigger updates
+function increment() {
+  ${name}.value++
+}
+
+export {
+  ${name},
+  increment,
+}
+`
+  });
+}
+async function makeLanguage(options) {
+  try {
+    const name = options.name;
+    log6.info("Creating your translation file...");
+    await createLanguage(options);
+    log6.success(`Created ${name} translation file`);
+  } catch (error) {
+    log6.error("There was an error creating your language.", error);
+    process2.exit();
+  }
+}
+async function createLanguage(options) {
+  const name = options.name;
+  await writeTextFile2({
+    path: p2.resourcesPath(`lang/${name}.yml`),
+    data: `button:
+  text: Copy
+`
+  });
+}
+function makeStack(options) {
+  try {
+    const name = options.name;
+    log6.info(`Creating your ${name} stack...`);
+    const path4 = resolve(process2.cwd(), name);
+    log6.success("Successfully scaffolded your project");
+    log6.info(`cd ${path4} && bun install`);
+  } catch (error) {
+    log6.error("There was an error creating your stack", error);
+    process2.exit();
+  }
+}
+async function createNotification(options) {
+  const name = options.name;
+  try {
+    let importOption = "EmailOptions";
+    if (!doesFolderExist("notifications"))
+      await createFolder("./notifications");
+    if (options.chat)
+      importOption = "ChatOptions";
+    if (options.sms)
+      importOption = "SMSOptions";
+    await writeTextFile2({
+      path: p2.userNotificationsPath(`${name}.ts`),
+      data: `import type { ${importOption} } from \'@stacksjs/types\'
+
+function content(): string {
+  return 'example'
+}
+
+function send(): ${importOption} {
+  return {
+    content: content(),
+  }
+}`
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function createMigration(options) {
+  const optionName = options.name;
+  const table = "dummy-name";
+  if (!optionName[0])
+    throw new Error("options.name is required and cannot be empty");
+  const name = optionName[0].toUpperCase() + optionName.slice(1);
+  const path4 = frameworkPath2(`database/migrations/${name}.ts`);
+  try {
+    await writeTextFile2({
+      path: `${path4}`,
+      data: `import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('${table}')
+    .addColumn('id', 'integer', col => col.autoIncrement().primaryKey())
+    .execute()
+}`
+    });
+    log6.success(`Successfully created your migration file at stacks/database/migrations/${name}.ts`);
+  } catch (error) {
+    log6.error(error);
+  }
+}
+async function createModel(options) {
+  const optionName = options.name;
+  if (!optionName[0])
+    throw new Error("options.name is required and cannot be empty");
+  const name = optionName[0].toUpperCase() + optionName.slice(1);
+  const path4 = p2.userModelsPath(`${name}.ts`);
+  try {
+    await writeTextFile2({
+      path: `${path4}`,
+      data: `import { faker } from '@stacksjs/faker'
+import { schema } from '@stacksjs/validation'
+import type { Model } from '@stacksjs/types'
+
+export default {
+  name: '${name}',
+
+  traits: {
+    useTimestamps: true,
+
+    useSeeder: {
+      count: 10,
+    },
+  },
+
+  attributes: {
+    // your attributes here
+  },
+} satisfies Model`
+    });
+    log6.success(`Model created: ${italic(`app/Models/${name}.ts`)}`);
+  } catch (error) {
+    log6.error(error);
+  }
+}
+
+// src/action.ts
+class Action3 {
+  name;
+  description;
+  fields;
+  rate;
+  tries;
+  backoff;
+  enabled;
+  handle;
+  constructor({ name, description, fields, handle, rate, tries, backoff, enabled }) {
+    this.name = name;
+    this.description = description;
+    this.fields = fields;
+    this.rate = rate;
+    this.tries = tries;
+    this.backoff = backoff;
+    this.enabled = enabled;
+    this.handle = handle;
+  }
+}
+export {
+  runSystemTrayDevServer,
+  make as runMake,
+  runFrontendDevServer,
+  runDocsDevServer,
+  runDevServer,
+  runDesktopDevServer,
+  runDashboardDevServer,
+  runComponentsDevServer,
+  commit as runCommit,
+  runBackendDevServer,
+  runApiDevServer,
+  add as runAdd,
+  runActions,
+  runAction,
+  makeStack,
+  makePage,
+  makeNotification,
+  makeLanguage,
+  makeFunction,
+  makeDatabase,
+  makeComponent,
+  makeAction,
+  invoke,
+  hasAction,
+  generateWebTypes2 as generateWebTypes,
+  generateVsCodeCustomData2 as generateVsCodeCustomData,
+  generateTypes,
+  generateSeeder,
+  generatePkgxConfig,
+  generateLibEntries,
+  generateIdeHelpers,
+  generateCoreSymlink,
+  generateComponentMeta,
+  generate,
+  createPage,
+  createNotification,
+  createModel,
+  createMigration,
+  createLanguage,
+  createFunction,
+  createFactory,
+  createDatabase,
+  createComponent,
+  Action3 as Action
+};

package/dist/key-generate.js

@@ -0,0 +1,10 @@
+// @bun
+// src/key-generate.ts
+import {runCommand} from "@stacksjs/cli";
+import {projectPath} from "@stacksjs/path";
+import {generateAppKey} from "@stacksjs/security";
+import {isFile} from "@stacksjs/storage";
+import {setEnvValue} from "@stacksjs/utils";
+if (!isFile(".env"))
+  await runCommand("cp .env.example .env", { cwd: projectPath() });
+await setEnvValue("APP_KEY", generateAppKey());

package/dist/lint/fix.js

@@ -0,0 +1,12 @@
+// @bun
+// src/lint/fix.ts
+import {log, parseOptions, runCommand} from "@stacksjs/cli";
+import {NpmScript} from "@stacksjs/enums";
+import {projectPath} from "@stacksjs/path";
+log.info("Ensuring Code Style...");
+var options = parseOptions();
+var result = await runCommand(NpmScript.LintFix, {
+  cwd: projectPath(),
+  ...options
+});
+log.success("Linted");

package/dist/lint/index.js

@@ -0,0 +1,16 @@
+// @bun
+// src/lint/index.ts
+import process from "process";
+import {log, runCommands} from "@stacksjs/cli";
+import {NpmScript} from "@stacksjs/enums";
+import {projectPath} from "@stacksjs/path";
+import {ExitCode} from "@stacksjs/types";
+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);
+}
+log.success("Linted");