@stacksjs/actions 0.70.87 → 0.70.90

package/dist/make-policy.js

@@ -1,35 +1,61 @@
-// @bun
-import{Lb as O}from"./chunk-h3d81wrg.js";import{log as B}from"@stacksjs/logging";import*as J from"@stacksjs/path";import{doesExist as Q,get as R,writeFile as L}from"@stacksjs/storage";async function X(q){let b=q.name;if(!b)return B.error("Policy name is required"),!1;let z=b.endsWith("Policy")?b:`${b}Policy`,v=q.model||z.replace("Policy",""),I=T(z,v),H=J.appPath(`Policies/${z}.ts`);try{let G=J.appPath("Policies");if(!Q(G)){let{mkdirSync:K}=await import("@stacksjs/storage");K(G,{recursive:!0})}if(await L(H,I),B.success(`Created policy: ${H}`),q.register!==!1)await U(v,z);return!0}catch(G){return B.error(`Failed to create policy: ${G.message}`),!1}}function T(q,b){return`import type _User from '../models/User'
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import { doesExist, get, writeFile } from "@stacksjs/storage";
+export async function makePolicy(options) {
+  const name = options.name;
+  if (!name) {
+    log.error("Policy name is required");
+    return !1;
+  }
+  const policyName = name.endsWith("Policy") ? name : `${name}Policy`, modelName = options.model || policyName.replace("Policy", ""), content = generatePolicyContent(policyName, modelName), filePath = p.appPath(`Policies/${policyName}.ts`);
+  try {
+    const policiesDir = p.appPath("Policies");
+    if (!doesExist(policiesDir)) {
+      const { mkdirSync } = await import("@stacksjs/storage");
+      mkdirSync(policiesDir, { recursive: !0 });
+    }
+    await writeFile(filePath, content);
+    log.success(`Created policy: ${filePath}`);
+    if (options.register !== !1)
+      await registerPolicy(modelName, policyName);
+    return !0;
+  } catch (error) {
+    log.error(`Failed to create policy: ${error.message}`);
+    return !1;
+  }
+}
+function generatePolicyContent(policyName, modelName) {
+  return `import type _User from '../models/User'
 import { BasePolicy } from '@stacksjs/auth'
 
 type UserModel = _User
 
 /**
- * ${q}
+ * ${policyName}
  *
- * This policy controls authorization for ${b} model actions.
+ * This policy controls authorization for ${modelName} model actions.
  *
  * Usage:
  * 1. Register in app/Gates.ts:
- *    policies: { '${b}': '${q}' }
+ *    policies: { '${modelName}': '${policyName}' }
  *
  * 2. Use in your code:
  *    import { Gate } from '@stacksjs/auth'
- *    await Gate.authorize('view', user, ${b.toLowerCase()})
+ *    await Gate.authorize('view', user, ${modelName.toLowerCase()})
  *
  * 3. Or use the middleware:
- *    route.put('/${b.toLowerCase()}s/:${b.toLowerCase()}', 'Update${b}')
- *      .middleware('can:update,${b.toLowerCase()}')
+ *    route.put('/${modelName.toLowerCase()}s/:${modelName.toLowerCase()}', 'Update${modelName}')
+ *      .middleware('can:update,${modelName.toLowerCase()}')
  */
 
-// TODO: Import or define your ${b} type
-interface ${b} {
+// TODO: Import or define your ${modelName} type
+interface ${modelName} {
   id: number
   user_id: number
   // Add your model properties here
 }
 
-export default class ${q} extends BasePolicy<${b}> {
+export default class ${policyName} extends BasePolicy<${modelName}> {
   /**
    * Run before any other checks.
    * Return true to allow, false to deny, null to continue.
@@ -41,54 +67,76 @@ export default class ${q} extends BasePolicy<${b}> {
   }
 
   /**
-   * Determine if the user can view any ${b.toLowerCase()}s.
+   * Determine if the user can view any ${modelName.toLowerCase()}s.
    */
   viewAny(user: UserModel | null): boolean {
     return true
   }
 
   /**
-   * Determine if the user can view the ${b.toLowerCase()}.
+   * Determine if the user can view the ${modelName.toLowerCase()}.
    */
-  view(user: UserModel | null, model: ${b}): boolean {
+  view(user: UserModel | null, model: ${modelName}): boolean {
     return true
   }
 
   /**
-   * Determine if the user can create ${b.toLowerCase()}s.
+   * Determine if the user can create ${modelName.toLowerCase()}s.
    */
   create(user: UserModel | null): boolean {
     return user !== null
   }
 
   /**
-   * Determine if the user can update the ${b.toLowerCase()}.
+   * Determine if the user can update the ${modelName.toLowerCase()}.
    */
-  update(user: UserModel | null, model: ${b}): boolean {
+  update(user: UserModel | null, model: ${modelName}): boolean {
     return user?.id === model.user_id
   }
 
   /**
-   * Determine if the user can delete the ${b.toLowerCase()}.
+   * Determine if the user can delete the ${modelName.toLowerCase()}.
    */
-  delete(user: UserModel | null, model: ${b}): boolean {
+  delete(user: UserModel | null, model: ${modelName}): boolean {
     return user?.id === model.user_id
   }
 
   /**
-   * Determine if the user can restore the ${b.toLowerCase()}.
+   * Determine if the user can restore the ${modelName.toLowerCase()}.
    */
-  restore(user: UserModel | null, model: ${b}): boolean {
+  restore(user: UserModel | null, model: ${modelName}): boolean {
     return user?.id === model.user_id
   }
 
   /**
-   * Determine if the user can permanently delete the ${b.toLowerCase()}.
+   * Determine if the user can permanently delete the ${modelName.toLowerCase()}.
    */
-  forceDelete(user: UserModel | null, model: ${b}): boolean {
+  forceDelete(user: UserModel | null, model: ${modelName}): boolean {
     return user?.id === model.user_id
   }
 }
-`}async function U(q,b){let z=J.appPath("Gates.ts");try{let v=await R(z),I=v.match(/export const policies[^{]*\{([^}]*)\}/);if(I){let H=I[1]??"";if(H.includes(`'${q}'`)){B.info(`Policy for '${q}' already registered in Gates.ts`);return}let G=`  '${q}': '${b}',
-`,K=`${H.trimEnd()}
-${G}`;v=v.replace(/export const policies[^{]*\{([^}]*)\}/,`export const policies: Record<string, string | { policy: string, model?: string }> = {${K}}`),await L(z,v),B.success(`Registered policy '${b}' for '${q}' in Gates.ts`)}}catch(v){B.warn(`Could not register policy in Gates.ts: ${v.message}`),B.info("You may need to manually add it to app/Gates.ts")}}export{X as makePolicy};
+`;
+}
+async function registerPolicy(modelName, policyName) {
+  const gatesPath = p.appPath("Gates.ts");
+  try {
+    let content = await get(gatesPath);
+    const policiesMatch = content.match(/export const policies[^{]*\{([^}]*)\}/);
+    if (policiesMatch) {
+      const existingPolicies = policiesMatch[1] ?? "";
+      if (existingPolicies.includes(`'${modelName}'`)) {
+        log.info(`Policy for '${modelName}' already registered in Gates.ts`);
+        return;
+      }
+      const newPolicy = `  '${modelName}': '${policyName}',
+`, updatedPolicies = `${existingPolicies.trimEnd()}
+${newPolicy}`;
+      content = content.replace(/export const policies[^{]*\{([^}]*)\}/, `export const policies: Record<string, string | { policy: string, model?: string }> = {${updatedPolicies}}`);
+      await writeFile(gatesPath, content);
+      log.success(`Registered policy '${policyName}' for '${modelName}' in Gates.ts`);
+    }
+  } catch (error) {
+    log.warn(`Could not register policy in Gates.ts: ${error.message}`);
+    log.info("You may need to manually add it to app/Gates.ts");
+  }
+}

package/dist/make-resource.js

@@ -1,27 +1,51 @@
-// @bun
-import{Lb as G}from"./chunk-h3d81wrg.js";import{log as x}from"@stacksjs/logging";import*as z from"@stacksjs/path";import{doesExist as H,writeFile as I}from"@stacksjs/storage";async function O(q){let j=q.name;if(!j)return x.error("Resource name is required"),!1;let v=j.endsWith("Resource")?j:`${j}Resource`,A=q.model||v.replace("Resource",""),F=q.collection?K(v,A):J(v,A),B=z.appPath("Resources");if(!H(B)){let{mkdirSync:w}=await import("@stacksjs/storage");w(B,{recursive:!0})}let E=z.appPath(`Resources/${v}.ts`);try{return await I(E,F),x.success(`Created resource: ${E}`),!0}catch(w){return x.error(`Failed to create resource: ${w.message}`),!1}}function J(q,j){return`import type { Request } from '@stacksjs/router'
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import { doesExist, writeFile } from "@stacksjs/storage";
+export async function makeResource(options) {
+  const name = options.name;
+  if (!name) {
+    log.error("Resource name is required");
+    return !1;
+  }
+  const resourceName = name.endsWith("Resource") ? name : `${name}Resource`, modelName = options.model || resourceName.replace("Resource", ""), content = options.collection ? generateCollectionResourceContent(resourceName, modelName) : generateResourceContent(resourceName, modelName), resourcesDir = p.appPath("Resources");
+  if (!doesExist(resourcesDir)) {
+    const { mkdirSync } = await import("@stacksjs/storage");
+    mkdirSync(resourcesDir, { recursive: !0 });
+  }
+  const filePath = p.appPath(`Resources/${resourceName}.ts`);
+  try {
+    await writeFile(filePath, content);
+    log.success(`Created resource: ${filePath}`);
+    return !0;
+  } catch (error) {
+    log.error(`Failed to create resource: ${error.message}`);
+    return !1;
+  }
+}
+function generateResourceContent(resourceName, modelName) {
+  return `import type { Request } from '@stacksjs/router'
 import { JsonResource } from '@stacksjs/api'
 
 /**
- * ${q}
+ * ${resourceName}
  *
- * Transforms ${j} model data for API responses.
+ * Transforms ${modelName} model data for API responses.
  *
  * @example
  * // Single resource
- * return new ${q}(${j.toLowerCase()}).toResponse()
+ * return new ${resourceName}(${modelName.toLowerCase()}).toResponse()
  *
  * // Collection
- * return ${q}.collection(${j.toLowerCase()}s).toResponse()
+ * return ${resourceName}.collection(${modelName.toLowerCase()}s).toResponse()
  *
  * // With additional data
- * return new ${q}(${j.toLowerCase()})
+ * return new ${resourceName}(${modelName.toLowerCase()})
  *   .withAdditional({ message: 'Success' })
  *   .toResponse()
  */
 
-// TODO: Import or define your ${j} type
-interface ${j} {
+// TODO: Import or define your ${modelName} type
+interface ${modelName} {
   id: number
   name: string
   created_at: Date
@@ -29,7 +53,7 @@ interface ${j} {
   // Add your model properties here
 }
 
-export default class ${q} extends JsonResource<${j}> {
+export default class ${resourceName} extends JsonResource<${modelName}> {
   /**
    * Transform the resource into an array.
    */
@@ -55,20 +79,24 @@ export default class ${q} extends JsonResource<${j}> {
     }
   }
 }
-`}function K(q,j){let v=q.replace("Collection","");return`import type { Request } from '@stacksjs/router'
+`;
+}
+function generateCollectionResourceContent(resourceName, modelName) {
+  const baseResourceName = resourceName.replace("Collection", "");
+  return `import type { Request } from '@stacksjs/router'
 import { JsonResource, ResourceCollection } from '@stacksjs/api'
 
 /**
- * ${q}
+ * ${resourceName}
  *
- * Collection resource for ${j} with custom collection behavior.
+ * Collection resource for ${modelName} with custom collection behavior.
  *
  * @example
- * return new ${q}(${j.toLowerCase()}s).toResponse()
+ * return new ${resourceName}(${modelName.toLowerCase()}s).toResponse()
  */
 
-// TODO: Import or define your ${j} type
-interface ${j} {
+// TODO: Import or define your ${modelName} type
+interface ${modelName} {
   id: number
   name: string
   created_at: Date
@@ -78,7 +106,7 @@ interface ${j} {
 /**
  * Individual resource for the collection
  */
-class ${v} extends JsonResource<${j}> {
+class ${baseResourceName} extends JsonResource<${modelName}> {
   toArray(request?: Request): Record<string, any> {
     return {
       id: this.resource.id,
@@ -92,9 +120,9 @@ class ${v} extends JsonResource<${j}> {
 /**
  * Collection resource with custom behavior
  */
-export default class ${q} extends ResourceCollection<${j}, ${v}> {
-  constructor(resources: ${j}[]) {
-    super(resources, ${v})
+export default class ${resourceName} extends ResourceCollection<${modelName}, ${baseResourceName}> {
+  constructor(resources: ${modelName}[]) {
+    super(resources, ${baseResourceName})
   }
 
   /**
@@ -110,4 +138,5 @@ export default class ${q} extends ResourceCollection<${j}, ${v}> {
     }
   }
 }
-`}export{O as makeResource};
+`;
+}

package/dist/make.js

@@ -1,2 +1,328 @@
-// @bun
-import{A as k,B as l,C as m,D as n,E as o,F as p,G as q,H as r,I as s,J as t,K as u,L as v,M as w,N as x,O as y,P as z,Q as A,R as B,q as a,r as b,s as c,t as d,u as e,v as f,w as g,x as h,y as i,z as j}from"./chunk-c74qv38e.js";import"./chunk-nty6mmx4.js";import"./chunk-s735m9mg.js";import"./chunk-0gadhvn7.js";import"./chunk-h3d81wrg.js";export{a as setDryRun,v as makeStack,y as makeQueueTable,p as makePage,m as makeNotification,o as makeMail,t as makeLanguage,r as makeFunction,i as makeDatabase,f as makeComponent,z as makeCertificate,e as makeAction,d as make,b as isDryRunActive,c as invoke,k as factory,q as createPage,w as createNotification,A as createModel,x as createMigration,B as createMiddleware,n as createMail,u as createLanguage,s as createFunction,l as createFactory,j as createDatabase,h as createComponent,g as createAction};
+import process from "node:process";
+import { existsSync } from "node:fs";
+import { italic, runCommand } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+import { localUrl } from "@stacksjs/config";
+import { Action } from "@stacksjs/enums";
+import { handleError } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import { frameworkPath, path as p, resolve } from "@stacksjs/path";
+import { createFolder, doesFolderExist, writeTextFile } from "@stacksjs/storage";
+import { kebabCase, pascalCase, template } from "@stacksjs/strings";
+import { runAction } from "./helpers";
+import { CODE_TEMPLATES } from "./templates";
+let isDryRun = !1;
+export function setDryRun(enabled) {
+  isDryRun = Boolean(enabled);
+}
+export function isDryRunActive() {
+  return isDryRun;
+}
+function generateCode(templateKey, ...args) {
+  return template(CODE_TEMPLATES[templateKey], ...args);
+}
+async function writeOrPreview(path, data) {
+  if (isDryRun) {
+    const lines = data.split(`
+`), preview = lines.slice(0, 60).map((l) => `  ${l}`).join(`
+`), truncated = lines.length > 60 ? `
+  ${italic(`\u2026 ${lines.length - 60} more lines elided`)}` : "";
+    log.info(`[dry-run] would write ${path} (${lines.length} lines)`);
+    process.stdout.write(`${preview}${truncated}
+
+`);
+    return;
+  }
+  await writeTextFile({ path, data });
+}
+async function createFileWithTemplate(path, templateKey, ...args) {
+  await writeOrPreview(path, generateCode(templateKey, ...args));
+}
+export async function invoke(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.middleware)
+    await createMiddleware(options);
+  if (options.notification)
+    await makeNotification(options);
+  if (options.page)
+    await makePage(options);
+  if (options.stack)
+    await makeStack(options);
+}
+export async function make(options) {
+  return await invoke(options);
+}
+export async function makeAction(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your action...");
+    await createAction(options);
+    log.success(`Created ${italic(name)} action`);
+  } catch (error) {
+    log.error("There was an error creating your action", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export async function makeComponent(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(ExitCode.FatalError);
+  }
+}
+export async function createAction(options) {
+  const name = options.name, opts = options, wantsValidation = Boolean(opts.withValidation || options["with-validation"]), wantsAuth = Boolean(opts.withAuth || options["with-auth"]), templateKey = wantsValidation && wantsAuth ? "actionWithBoth" : wantsValidation ? "actionWithValidation" : wantsAuth ? "actionWithAuth" : "action";
+  await createFileWithTemplate(p.userActionsPath(name), templateKey, name);
+}
+export async function createComponent(options) {
+  const name = options.name;
+  await createFileWithTemplate(p.userComponentsPath(`${name}.vue`), "component", name);
+}
+export function makeDatabase(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} database...`);
+    createDatabase(options);
+    log.success(`Created ${italic(name)} database`);
+  } catch (error) {
+    log.error("There was an error creating your database", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export function createDatabase(options) {
+  log.debug("createDatabase options", options);
+}
+export function factory(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} factory...`);
+    createDatabase(options);
+    log.success(`Created ${italic(name)} factory`);
+  } catch (error) {
+    log.error("There was an error creating your factory", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export async function createFactory(options) {
+  const name = options.name || "MyFactory", factoryName = name.endsWith("Factory") ? name : `${name}Factory`;
+  try {
+    const { path: p } = await import("@stacksjs/path"), factoryPath = `${p.userDatabasePath("factories")}/${factoryName}.ts`;
+    if (await Bun.file(factoryPath).exists()) {
+      log.warn(`Factory ${factoryName} already exists at ${factoryPath}`);
+      return;
+    }
+    const modelName = name.replace(/Factory$/, ""), content = `import type { ${modelName}Model } from '@stacksjs/orm'
+
+export function ${factoryName}(): Partial<${modelName}Model> {
+  return {
+    // Define your factory attributes here
+  }
+}
+
+export default ${factoryName}
+`;
+    await writeOrPreview(factoryPath, content);
+    log.success(`Created factory: ${factoryPath}`);
+  } catch (error) {
+    log.error(`Failed to create factory ${factoryName}`, error);
+    throw error;
+  }
+}
+export async function makeNotification(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(ExitCode.FatalError);
+  }
+}
+export async function createMail(options) {
+  const rawName = String(options.name || "").trim();
+  if (!rawName) {
+    log.error("A mail name is required (e.g. `buddy make:mail OrderShipped`).");
+    return !1;
+  }
+  const className = pascalCase(rawName), kebabName = kebabCase(rawName), mailPath = p.userMailPath(`${className}.ts`), templatePath = p.userEmailsPath(`${kebabName}.stx`);
+  if (!options.force) {
+    if (existsSync(mailPath)) {
+      console.error(`${italic(mailPath)} already exists \u2014 re-run with --force to overwrite.`);
+      return !1;
+    }
+    if (existsSync(templatePath)) {
+      console.error(`${italic(templatePath)} already exists \u2014 re-run with --force to overwrite.`);
+      return !1;
+    }
+  }
+  if (!doesFolderExist(p.userMailPath()))
+    await createFolder(p.userMailPath());
+  if (!doesFolderExist(p.userEmailsPath()))
+    await createFolder(p.userEmailsPath());
+  try {
+    await createFileWithTemplate(mailPath, "mail", className, kebabName);
+    await createFileWithTemplate(templatePath, "mailTemplate", className, kebabName);
+    return !0;
+  } catch (error) {
+    handleError("Error creating mailable", error);
+    return !1;
+  }
+}
+export async function makeMail(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${italic(name)} mailable...`);
+    if (!await createMail(options))
+      process.exit(ExitCode.FatalError);
+    log.success(`Created ${italic(pascalCase(name))} mailable + ${italic(kebabCase(name))}.stx template`);
+  } catch (error) {
+    log.error("There was an error creating your mailable", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export async function makePage(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your page...");
+    await createPage(options);
+    log.success(`Created ${name} page`);
+  } catch (error) {
+    log.error("There was an error creating your page", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export async function createPage(options) {
+  const name = options.name;
+  await createFileWithTemplate(p.userViewsPath(`${name}.vue`), "page", name);
+}
+export async function makeFunction(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(ExitCode.FatalError);
+  }
+}
+export async function createFunction(options) {
+  const name = options.name;
+  await createFileWithTemplate(p.userFunctionsPath(`${name}.ts`), "function", name);
+}
+export async function makeLanguage(options) {
+  try {
+    const name = options.name;
+    log.info("Creating your translation file...");
+    await createLanguage(options);
+    log.success(`Created ${name} translation file`);
+  } catch (error) {
+    log.error("There was an error creating your language.", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export async function createLanguage(options) {
+  const name = options.name;
+  await createFileWithTemplate(p.resourcesPath(`lang/${name}.yml`), "language", name);
+}
+export async function makeStack(options) {
+  try {
+    const name = options.name;
+    log.info(`Creating your ${name} stack...`);
+    const stackDir = resolve(process.cwd(), name);
+    if (doesFolderExist(stackDir)) {
+      log.error(`Directory "${name}" already exists`);
+      process.exit(ExitCode.FatalError);
+    }
+    await createFolder(stackDir);
+    const dirs = ["app/Actions", "app/Models", "config", "database/migrations", "resources/views", "resources/components", "resources/functions", "routes", "public"];
+    for (const dir of dirs)
+      await createFolder(resolve(stackDir, dir));
+    const shortName = name.replace(/^@[^/]+\//, "").replace(/-stack$/, "");
+    await createFileWithTemplate(resolve(stackDir, "package.json"), "stackPackageJson", name, shortName);
+    log.success(`Successfully scaffolded your "${name}" stack`);
+    log.info("");
+    log.info(`  cd ${name}`);
+    log.info("  # Add your models, actions, views, etc.");
+    log.info("  # Then publish: bun publish");
+    log.info("");
+    log.info("  Users install it with:");
+    log.info(`  buddy stack:install ${name}`);
+  } catch (error) {
+    log.error("There was an error creating your stack", error);
+    process.exit(ExitCode.FatalError);
+  }
+}
+export 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 createFileWithTemplate(p.userNotificationsPath(`${name}.ts`), "notification", importOption);
+    return !0;
+  } catch (error) {
+    handleError("Error creating notification", error);
+    return !1;
+  }
+}
+export async function createMigration(options) {
+  const optionName = options.name, table = "dummy-name";
+  if (!optionName[0])
+    throw Error("options.name is required and cannot be empty");
+  const name = optionName[0].toUpperCase() + optionName.slice(1), path = frameworkPath(`database/migrations/${name}.ts`);
+  try {
+    await createFileWithTemplate(path, "migration", table);
+    log.success(`Successfully created your migration file at stacks/database/migrations/${name}.ts`);
+  } catch (error) {
+    log.error(error);
+  }
+}
+export async function makeQueueTable() {
+  await runAction(Action.QueueTable);
+}
+export async function makeCertificate() {
+  const domain = await localUrl();
+  log.info("Creating SSL certificate...");
+  await runCommand(`tlsx ${domain}`, {
+    cwd: p.storagePath("keys")
+  });
+  log.success("Certificate created");
+  log.info("Installing SSL certificate...");
+  await runCommand("tlsx -install", {
+    cwd: p.storagePath("keys")
+  });
+  log.success("Certificate installed");
+}
+export async function createModel(options) {
+  const optionName = options.name;
+  if (!optionName[0])
+    throw Error("options.name is required and cannot be empty");
+  const name = optionName[0].toUpperCase() + optionName.slice(1), tableName = name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/([^s])$/, "$1s"), path = p.userModelsPath(`${name}.ts`);
+  try {
+    await createFileWithTemplate(path, "model", name, tableName);
+    log.success(`Model created: ${italic(`app/Models/${name}.ts`)}`);
+  } catch (error) {
+    log.error(error);
+  }
+}
+export async function createMiddleware(options) {
+  const name = options.name;
+  await createFileWithTemplate(p.userMiddlewarePath(`${name}.ts`), "middleware", name);
+}

package/dist/migrate/database.js

@@ -1,2 +1,16 @@
-// @bun
-import i from"process";import{generateMigrations as t,runDatabaseMigration as a}from"@stacksjs/database";import{log as e}from"@stacksjs/logging";var r=await t();if(r?.isErr)console.error(r.error),e.error("[stacks] generateMigrations failed",r.error),i.exit(1);var o=await a();if(o.isErr)e.error("runDatabaseMigration failed"),e.error(o.error),i.exit(1);i.exit(0);
+import process from "node:process";
+import { generateMigrations, runDatabaseMigration } from "@stacksjs/database";
+import { log } from "@stacksjs/logging";
+const result = await generateMigrations();
+if (result?.isErr) {
+  console.error(result.error);
+  log.error("[stacks] generateMigrations failed", result.error);
+  process.exit(1);
+}
+const migrateResult = await runDatabaseMigration();
+if (migrateResult.isErr) {
+  log.error("runDatabaseMigration failed");
+  log.error(migrateResult.error);
+  process.exit(1);
+}
+process.exit(0);

package/dist/migrate/fresh.js

@@ -1,2 +1,31 @@
-// @bun
-import v from"process";import{generateMigrations as G,migrateAuthTables as H,migrateNotificationTables as I,migrateRbacTables as J,resetDatabase as K,runDatabaseMigration as L}from"@stacksjs/database";import{log as q}from"@stacksjs/logging";var w=await K();if(w?.isErr)console.error(w.error),q.error("resetDatabase failed",w.error),v.exit(1);var x=await G();if(x?.isErr)console.error(x.error),q.error("generateMigrations failed",x.error),v.exit(1);var z=await H();if(!z.success)q.error(`Failed to migrate auth tables: ${z.error}`);var B=await I();if(!B.success)q.error(`Failed to migrate notification tables: ${B.error}`);var C=await J();if(!C.success)q.error(`Failed to migrate RBAC tables: ${C.error}`);var E=await L();if(E.isErr)q.error("runDatabaseMigration failed"),q.error(E.error),v.exit(1);v.exit(0);
+import process from "node:process";
+import { generateMigrations, migrateAuthTables, migrateNotificationTables, migrateRbacTables, resetDatabase, runDatabaseMigration } from "@stacksjs/database";
+import { log } from "@stacksjs/logging";
+const resetResult = await resetDatabase();
+if (resetResult?.isErr) {
+  console.error(resetResult.error);
+  log.error("resetDatabase failed", resetResult.error);
+  process.exit(1);
+}
+const genResult = await generateMigrations();
+if (genResult?.isErr) {
+  console.error(genResult.error);
+  log.error("generateMigrations failed", genResult.error);
+  process.exit(1);
+}
+const authResult = await migrateAuthTables();
+if (!authResult.success)
+  log.error(`Failed to migrate auth tables: ${authResult.error}`);
+const notifResult = await migrateNotificationTables();
+if (!notifResult.success)
+  log.error(`Failed to migrate notification tables: ${notifResult.error}`);
+const rbacResult = await migrateRbacTables();
+if (!rbacResult.success)
+  log.error(`Failed to migrate RBAC tables: ${rbacResult.error}`);
+const migrateResult = await runDatabaseMigration();
+if (migrateResult.isErr) {
+  log.error("runDatabaseMigration failed");
+  log.error(migrateResult.error);
+  process.exit(1);
+}
+process.exit(0);