@stacksjs/actions 0.70.88 → 0.70.91

package/dist/helpers/package-json.d.ts

@@ -0,0 +1,2 @@
+export declare function generatePackageJson(type: PackageJsonType): Promise<void>;
+declare type PackageJsonType = 'web-components' | 'functions';

package/dist/helpers/package-json.js

@@ -0,0 +1,74 @@
+import { log } from "@stacksjs/logging";
+import { packageJsonPath } from "@stacksjs/path";
+import { writeTextFile } from "@stacksjs/storage";
+import library from "~/config/library";
+export async function generatePackageJson(type) {
+  let name, description, directory, keywords, config, prettyName;
+  if (type === "web-components") {
+    name = library.webComponents?.name;
+    description = library.webComponents?.description;
+    directory = "components";
+    keywords = library.webComponents?.keywords;
+    config = "web-components";
+  } else if (type === "functions") {
+    name = library.functions?.name;
+    description = library.functions?.description;
+    directory = "functions";
+    keywords = library.functions?.keywords;
+    config = "functions";
+  }
+  try {
+    await writeTextFile({
+      path: packageJsonPath(type),
+      data: `{
+  "name": "${name}",
+  "type": "module",
+  "version": "",
+  "packageManager": "bun",
+  "description": "${description}",
+  "author": "${library.author}",
+  "license": "MIT",
+  "homepage": "https://github.com/${library.repository}/tree/main/${directory}#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/${library.repository}.git",
+    "directory": "${directory}"
+  },
+  "bugs": {
+    "url": "https://github.com/${library.repository}/issues"
+  },
+  "keywords": ${JSON.stringify(keywords)},
+  "contributors": ${JSON.stringify(library.contributors)},
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.js",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "vite build -c ../build/${config}.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "stacks": "workspace:*"
+  }
+}
+`
+    });
+    if (type === "web-components")
+      prettyName = "Web Component library";
+    else if (type === "functions")
+      prettyName = "Function Library";
+    log.success(`Created ${prettyName} package.json file`);
+  } catch (err) {
+    log.error(`There was an error creating the ${prettyName} package.json`, err);
+  }
+}

package/dist/helpers/utils.d.ts

@@ -0,0 +1,23 @@
+import type { ActionOptions, CommandError, Subprocess } from '@stacksjs/types';
+import type { Result } from '@stacksjs/error-handling';
+/**
+ * Run an Action the Stacks way.
+ *
+ * @param action The action to invoke.
+ * @param options The options to pass to the command.
+ * @returns The result of the command.
+ */
+export declare function runAction(action: Action, options?: ActionOptions): Promise<Result<Subprocess, CommandError>>;
+/**
+ * Run Actions the Stacks way.
+ *
+ * @param actions The actions to invoke.
+ * @param options The options to pass to the command.
+ * @returns The result of the command.
+ */
+export declare function runActions(actions: Action[], options?: ActionOptions): Promise<any>;
+// looks in most common locations
+export declare function hasAction(action: Action): boolean;
+declare type ActionPath = string // TODO: narrow this by automating its generation
+type ActionName = string // TODO: narrow this by automating its generation
+type Action = ActionPath | ActionName | string;

package/dist/helpers/utils.js

@@ -0,0 +1,105 @@
+var {require}=import.meta;import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { buddyOptions, runCommand, runCommands } from "@stacksjs/cli";
+import { err } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+async function resolveActionFile(action) {
+  const candidates = [];
+  candidates.push(p.actionsPath(`src/${action}.ts`));
+  try {
+    const pkgUrl = import.meta.resolve("@stacksjs/actions/package.json");
+    if (pkgUrl) {
+      const pkgPath = new URL(pkgUrl).pathname, pkgRoot = pkgPath.slice(0, pkgPath.lastIndexOf("/"));
+      candidates.push(`${pkgRoot}/dist/${action}.js`);
+      candidates.push(`${pkgRoot}/dist/src/${action}.js`);
+      candidates.push(`${pkgRoot}/src/${action}.ts`);
+    }
+  } catch {}
+  for (const candidate of candidates)
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  return null;
+}
+export async function runAction(action, options) {
+  log.debug(`[action] Running: ${action}`);
+  if (action === "dev/views")
+    try {
+      const pantryPath = p.projectPath("pantry");
+      if (!process.env.NODE_PATH?.includes(pantryPath)) {
+        process.env.NODE_PATH = process.env.NODE_PATH ? `${pantryPath}:${process.env.NODE_PATH}` : pantryPath;
+        require("module").Module._initPaths?.();
+      }
+      const viewsEntries = [
+        p.projectPath("storage/framework/core/actions/src/dev/views.ts"),
+        p.frameworkPath("actions/src/dev/views.ts")
+      ];
+      for (const entry of viewsEntries)
+        if (existsSync(entry)) {
+          await import(entry);
+          return { ok: !0, value: {} };
+        }
+      return err("dev/views entry not found");
+    } catch (error) {
+      return err(`Failed to start dev server: ${error}`);
+    }
+  if (!(action.includes("/") || ["dev", "build", "install", "upgrade", "migrate"].some((prefix) => action.startsWith(prefix)))) {
+    const glob = new Bun.Glob("**/*.{ts,js}"), scanOptions = { cwd: p.userActionsPath(), onlyFiles: !0, absolute: !0 }, matchingFiles = [], basePath = p.userActionsPath();
+    for await (const file of glob.scan(scanOptions)) {
+      if (file.replace(`${basePath}/`, "").replace(/\.(ts|js)$/, "") === action || file.endsWith(`${action}.ts`) || file.endsWith(`${action}.js`)) {
+        log.debug(`[action] Resolved: ${action} \u2192 ${file}`);
+        return await (await import(file)).default.handle(void 0);
+      }
+      matchingFiles.push(file);
+    }
+    for (const file of matchingFiles)
+      try {
+        const a = await import(file);
+        if (a.name === action) {
+          log.debug(`[action] Resolved: ${action} \u2192 ${file}`);
+          return await a.handle();
+        }
+      } catch (error) {}
+  }
+  const path = await resolveActionFile(action);
+  if (!path)
+    return err(`Action '${action}' not found in storage/framework/core/actions/src or @stacksjs/actions`);
+  log.debug(`[action] Resolved: ${action} \u2192 ${path}`);
+  const isDevAction = action.startsWith("dev/"), watchFlag = isDevAction ? "--watch" : "", opts = isDevAction ? "" : buddyOptions(options) || "", cmd = `bun ${watchFlag} ${path} ${opts}`.trimEnd(), pantryNodePath = p.projectPath("pantry"), existingNodePath = process.env.NODE_PATH, nodePath = existingNodePath ? `${pantryNodePath}:${existingNodePath}` : pantryNodePath, shouldInherit = options?.verbose || isDevAction && !options?.quiet, optionsWithCwd = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options,
+    stdout: shouldInherit ? "inherit" : void 0,
+    stderr: shouldInherit ? "inherit" : void 0,
+    env: { ...options?.env, NODE_PATH: nodePath, ...isDevAction ? { STACKS_DEV_SERVER: "1" } : {} }
+  }, result = await runCommand(cmd, optionsWithCwd);
+  log.debug(`[action] Completed: ${action}`);
+  return result;
+}
+export 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 opts = buddyOptions(options) || "", o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  }, commands = actions.map((action) => `bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`);
+  return await runCommands(commands, o);
+}
+export function hasAction(action) {
+  const userActionPatterns = [
+    `${action}.ts`,
+    `${action}`,
+    `Dashboard/${action}.ts`,
+    `Dashboard/${action}`,
+    `Buddy/${action}.ts`,
+    `Buddy/${action}`
+  ], actionPatterns = [`src/${action}.ts`, `src/${action}`, `${action}.ts`, `${action}`];
+  return [
+    ...userActionPatterns.map((pattern) => p.userActionsPath(pattern)),
+    ...actionPatterns.map((pattern) => p.actionsPath(pattern))
+  ].some((candidate) => existsSync(candidate));
+}

package/dist/helpers/vscode-custom-data.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@stacksjs/error-handling';
+export declare function generateVsCodeCustomData(): Promise<Result<void, string>>;
+export declare function generateWebTypes(): Promise<void>;

package/dist/helpers/vscode-custom-data.js

@@ -0,0 +1,30 @@
+import { err, ok } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import { customElementsDataPath } from "@stacksjs/path";
+import { writeTextFile } from "@stacksjs/storage";
+import library from "~/config/library";
+function generateComponentInfoData() {
+  return `{
+  "version": 1.1,
+  "tags": ${JSON.stringify(library.webComponents?.tags)}
+}
+`;
+}
+export async function generateVsCodeCustomData() {
+  try {
+    log.info("Generating custom-elements.json...");
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+    log.success("Generated custom-elements.json for IDEs.");
+    return ok(void 0);
+  } catch (e) {
+    log.error("There was an error generating the custom-elements.json file.", e);
+    return err("There was an error generating the custom-elements.json file.");
+  }
+}
+export async function generateWebTypes() {
+  log.info("Generating web-types.json...");
+  log.info("This feature is not yet implemented.");
+}

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+export type { CrudField } from './scaffold-crud';
+export type { DiscoveredPackagesManifest, PackageStacksMeta } from './discover-packages';
+export * from './action';
+export { add as runAdd } from './add';
+// The write side of the markdown blog (content/blog/*.md), used by the
+// dashboard's blog actions. The read/render side lives in ./blog and stays out
+// of this barrel because it lazy-loads BunPress.
+export {
+  type BlogPost,
+  BlogAdminError,
+  type BlogPostInput,
+  deleteBlogPost,
+  getBlogPost,
+  listBlogPosts,
+  saveBlogPost,
+  slugify as blogSlugify,
+} from './blog-admin';
+export { commit as runCommit } from './commit';
+export * from './dev/index';
+export * from './generate/index';
+export * from './helpers/index';
+// Code-style actions, exported so commands import + call them directly
+// (`import { lintProject, lintFix } from '@stacksjs/actions'`) instead of
+// spawning a deep dist path. Exported from ./lint/lint — the pure module — so
+// importing the barrel never pulls the process-exiting ./lint/index script.
+export { formatProject, lintFix, lintProject } from './lint/lint';
+export * from './setup/index';
+// makeFactory,
+export {
+  createComponent,
+  createDatabase,
+  createFactory,
+  createFunction,
+  createLanguage,
+  createMiddleware,
+  createMigration,
+  createModel,
+  createMail,
+  createNotification,
+  createPage,
+  isDryRunActive,
+  makeAction,
+  makeCertificate,
+  makeComponent,
+  makeDatabase,
+  makeFunction,
+  makeLanguage,
+  makeMail,
+  makeNotification,
+  makePage,
+  makeQueueTable,
+  makeStack,
+  make as runMake,
+  setDryRun,
+} from './make';
+export { discoverPackages } from './discover-packages';
+export { parseFields, scaffoldCrud } from './scaffold-crud';
+export { installStack, uninstallStack, listStacks } from './stacks';
+export { makeJob } from './make-job';
+export { makeCommand } from './make-command';
+export { makePolicy } from './make-policy';
+export { makeResource } from './make-resource';

package/dist/index.js

@@ -0,0 +1,50 @@
+export * from "./action";
+export { add as runAdd } from "./add";
+export {
+  BlogAdminError,
+  deleteBlogPost,
+  getBlogPost,
+  listBlogPosts,
+  saveBlogPost,
+  slugify as blogSlugify
+} from "./blog-admin";
+export { commit as runCommit } from "./commit";
+export * from "./dev";
+export * from "./generate";
+export * from "./helpers";
+export { formatProject, lintFix, lintProject } from "./lint/lint";
+export * from "./setup";
+export {
+  createComponent,
+  createDatabase,
+  createFactory,
+  createFunction,
+  createLanguage,
+  createMiddleware,
+  createMigration,
+  createModel,
+  createMail,
+  createNotification,
+  createPage,
+  isDryRunActive,
+  makeAction,
+  makeCertificate,
+  makeComponent,
+  makeDatabase,
+  makeFunction,
+  makeLanguage,
+  makeMail,
+  makeNotification,
+  makePage,
+  makeQueueTable,
+  makeStack,
+  make as runMake,
+  setDryRun
+} from "./make";
+export { discoverPackages } from "./discover-packages";
+export { parseFields, scaffoldCrud } from "./scaffold-crud";
+export { installStack, uninstallStack, listStacks } from "./stacks";
+export { makeJob } from "./make-job";
+export { makeCommand } from "./make-command";
+export { makePolicy } from "./make-policy";
+export { makeResource } from "./make-resource";

package/dist/key-generate.d.ts

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

package/dist/key-generate.js

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { runCommand } from "@stacksjs/cli";
+import { generateKeypair } from "@stacksjs/env";
+import { projectPath } from "@stacksjs/path";
+import { generateAppKey } from "@stacksjs/security";
+import { existsSync } from "@stacksjs/storage";
+import { setEnvValue } from "@stacksjs/utils";
+if (!existsSync(".env"))
+  await runCommand("cp .env.example .env", { cwd: projectPath() });
+await setEnvValue("APP_KEY", generateAppKey());
+const envText = (() => {
+  try {
+    return readFileSync(projectPath(".env"), "utf-8");
+  } catch {
+    return "";
+  }
+})(), hasPublic = /^DOTENV_PUBLIC_KEY=.+$/m.test(envText), hasPrivate = /^DOTENV_PRIVATE_KEY=.+$/m.test(envText);
+if (!hasPublic || !hasPrivate) {
+  const { publicKey, privateKey } = generateKeypair();
+  if (!hasPublic)
+    await setEnvValue("DOTENV_PUBLIC_KEY", publicKey);
+  if (!hasPrivate)
+    await setEnvValue("DOTENV_PRIVATE_KEY", privateKey);
+}

package/dist/lint/fix.d.ts

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

package/dist/lint/fix.js

@@ -0,0 +1,4 @@
+import process from "node:process";
+import { lintFix } from "./lint";
+const { ok } = await lintFix();
+process.exit(ok ? 0 : 1);

package/dist/lint/index.d.ts

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

package/dist/lint/index.js

@@ -0,0 +1,4 @@
+import process from "node:process";
+import { lintProject } from "./lint";
+const { ok } = await lintProject();
+process.exit(ok ? 0 : 1);

package/dist/lint/lint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lint (optionally auto-fix) the project's tracked source via pickier's SDK.
+ * Returns `{ ok }` rather than exiting, so callers keep control of the process.
+ * pickier auto-discovers its own config (pickier.config.ts, .config/pickier.ts,
+ * …), so we don't pass one.
+ */
+export declare function lintProject(options?: { cwd?: string, fix?: boolean }): Promise<{ ok: boolean }>;
+/** Auto-fix the project's code style — `lintProject` with fixing enabled. */
+export declare function lintFix(options?: { cwd?: string }): Promise<{ ok: boolean }>;
+/**
+ * Format the project via pickier's SDK. `write` applies changes; `check`
+ * verifies formatting without writing (fails if anything is unformatted).
+ */
+export declare function formatProject(options?: { cwd?: string, write?: boolean, check?: boolean }): Promise<{ ok: boolean }>;

package/dist/lint/lint.js

@@ -0,0 +1,34 @@
+import process from "node:process";
+import { log } from "@stacksjs/cli";
+import { execSync } from "node:child_process";
+import { runFormat, runLint } from "pickier";
+const lintableFile = /\.(?:ts|js|json|md|yaml|yml)$/i, ignoredPath = /(?:^|\/)(?:node_modules|dist|pantry|storage\/framework\/cache|\.git|\.stx|\.stx-serve)(?:\/|$)/;
+function trackedFiles(cwd) {
+  try {
+    return execSync("git ls-files -z", { cwd, encoding: "utf8" }).split("\x00").filter((file) => lintableFile.test(file) && !ignoredPath.test(file));
+  } catch {
+    return [];
+  }
+}
+export async function lintProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  log.info(options.fix ? "Ensuring Code Style..." : "Checking Code Style...");
+  const files = trackedFiles(cwd);
+  if (!files.length) {
+    log.success("Linted");
+    return { ok: !0 };
+  }
+  const ok = await runLint(files, { maxWarnings: 9999, fix: options.fix }) === 0;
+  if (ok)
+    log.success("Linted");
+  return { ok };
+}
+export function lintFix(options = {}) {
+  return lintProject({ ...options, fix: !0 });
+}
+export async function formatProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd(), files = trackedFiles(cwd);
+  if (!files.length)
+    return { ok: !0 };
+  return { ok: await runFormat(files, { write: options.write, check: options.check }) === 0 };
+}

package/dist/make-command.d.ts

@@ -0,0 +1,10 @@
+import type { MakeOptions } from '@stacksjs/types';
+/**
+ * Create a new command file in app/Commands
+ */
+export declare function makeCommand(options: MakeCommandOptions): Promise<boolean>;
+export declare interface MakeCommandOptions extends MakeOptions {
+  register?: boolean
+  description?: string
+  signature?: string
+}

package/dist/make-command.js

@@ -0,0 +1,95 @@
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import { get, writeFile } from "@stacksjs/storage";
+export async function makeCommand(options) {
+  const name = options.name;
+  if (!name) {
+    log.error("Command name is required");
+    return !1;
+  }
+  const commandName = toPascalCase(name), content = generateCommandContent(commandName, options), filePath = p.commandsPath(`${commandName}.ts`);
+  try {
+    await writeFile(filePath, content);
+    log.success(`Created command: ${filePath}`);
+    if (options.register !== !1)
+      await registerCommand(commandName, options.signature || toKebabCase(name));
+    return !0;
+  } catch (error) {
+    log.error(`Failed to create command: ${error.message}`);
+    return !1;
+  }
+}
+function generateCommandContent(name, options) {
+  const signature = options.signature || toKebabCase(name), description = options.description || `The ${signature} command`;
+  return `import type { CLI } from '@stacksjs/types'
+import { log } from '@stacksjs/cli'
+
+/**
+ * ${name} Command
+ *
+ * ${description}
+ */
+
+interface ${name}Options {
+  verbose: boolean
+  // Add your command options here
+}
+
+export default function (cli: CLI) {
+  cli
+    .command('${signature}', '${description}')
+    .option('--verbose', 'Enable verbose output', { default: false })
+    // Add more options here
+    // .option('-n, --name <name>', 'Your name')
+    .action(async (options: ${name}Options) => {
+      try {
+        if (options.verbose) {
+          log.info('Running ${signature} command...')
+        }
+
+        log.info('No command logic implemented yet. Update this command action to add behavior.')
+
+        log.success('${signature} completed successfully!')
+      }
+      catch (error) {
+        log.error('${signature} failed:', error)
+        throw error
+      }
+    })
+
+  // Handle unknown subcommands
+  cli.on('${signature}:*', () => {
+    log.error('Invalid command: %s\\nSee --help for a list of available commands.', cli.args.join(' '))
+  })
+}
+`;
+}
+async function registerCommand(name, signature) {
+  const commandsPath = p.appPath("Commands.ts");
+  try {
+    let content = await get(commandsPath);
+    const exportMatch = content.match(/export default \{([\s\S]*)\} satisfies/);
+    if (exportMatch) {
+      const existingCommands = exportMatch[1] ?? "";
+      if (existingCommands.includes(`'${signature}'`)) {
+        log.info(`Command '${signature}' already registered in Commands.ts`);
+        return;
+      }
+      const newCommand = `  '${signature}': '${name}',
+`, updatedCommands = `${existingCommands.trimEnd()}
+${newCommand}`;
+      content = content.replace(/export default \{[\s\S]*\} satisfies/, `export default {${updatedCommands}} satisfies`);
+      await writeFile(commandsPath, content);
+      log.success(`Registered command '${signature}' in Commands.ts`);
+    }
+  } catch (error) {
+    log.warn(`Could not register command in Commands.ts: ${error.message}`);
+    log.info("You may need to manually add it to app/Commands.ts");
+  }
+}
+function toPascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}

package/dist/make-job.d.ts

@@ -0,0 +1,5 @@
+import type { MakeOptions } from '@stacksjs/types';
+/**
+ * Create a new job file in app/Jobs
+ */
+export declare function makeJob(options: MakeOptions): Promise<boolean>;