@stacksjs/actions 0.70.88 → 0.70.90

package/dist/make-job.js

@@ -0,0 +1,154 @@
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import { writeFile } from "@stacksjs/storage";
+export async function makeJob(options) {
+  const jobOptions = options, name = options.name;
+  if (!name) {
+    log.error("Job name is required");
+    return !1;
+  }
+  const jobName = name.endsWith("Job") ? name : `${name}Job`, content = jobOptions.class ?? !1 ? generateClassBasedJob(jobName, jobOptions) : generateFunctionBasedJob(jobName, jobOptions), filePath = p.userJobsPath(`${jobName}.ts`);
+  try {
+    await writeFile(filePath, content);
+    log.success(`Created job: ${filePath}`);
+    return !0;
+  } catch (error) {
+    log.error(`Failed to create job: ${error.message}`);
+    return !1;
+  }
+}
+function generateFunctionBasedJob(name, options) {
+  const queue = options.queue ?? "default", tries = options.tries ?? 3, backoff = options.backoff ?? 3;
+  return `import { Job } from '@stacksjs/queue'
+
+export default new Job({
+  /**
+   * The job name (optional, defaults to filename)
+   */
+  name: '${name}',
+
+  /**
+   * A description of what this job does (optional)
+   */
+  description: '${name} job',
+
+  /**
+   * The queue this job should be dispatched to
+   */
+  queue: '${queue}',
+
+  /**
+   * Number of times to retry if the job fails
+   */
+  tries: ${tries},
+
+  /**
+   * Seconds to wait between retry attempts
+   */
+  backoff: ${backoff},
+
+  /**
+   * Cron expression for scheduled jobs (optional)
+   * Examples:
+   *   - '* * * * *' - Every minute
+   *   - '0 * * * *' - Every hour
+   *   - '0 0 * * *' - Every day at midnight
+   */
+  // rate: '* * * * *',
+
+  /**
+   * Backoff configuration for advanced retry strategies (optional)
+   */
+  // backoffConfig: {
+  //   strategy: 'exponential', // 'fixed' | 'exponential' | 'linear'
+  //   initialDelay: 1000,
+  //   factor: 2,
+  //   maxDelay: 60000,
+  // },
+
+  /**
+   * Handle the job
+   * @param payload - The job payload data
+   * @returns The result of the job processing
+   */
+  async handle(payload: Record<string, unknown>) {
+    // Add your job logic here.
+    console.log('Processing job with payload:', payload)
+
+    return { success: true }
+  },
+})
+`;
+}
+function generateClassBasedJob(name, options) {
+  const queue = options.queue ?? "default", tries = options.tries ?? 3;
+  return `import { log } from '@stacksjs/logging'
+
+/**
+ * ${name}
+ *
+ * Generated job class.
+ */
+export default class ${name} {
+  /**
+   * Job configuration
+   */
+  public static config = {
+    /**
+     * The queue this job should be dispatched to
+     */
+    queue: '${queue}',
+
+    /**
+     * Cron expression for scheduled jobs (optional)
+     * Examples:
+     *   - '* * * * *' - Every minute
+     *   - '0 * * * *' - Every hour
+     *   - '0 0 * * *' - Every day at midnight
+     */
+    // schedule: '0 0 * * *',
+
+    /**
+     * Prevent overlapping job executions
+     */
+    withoutOverlapping: false,
+
+    /**
+     * Timeout in seconds
+     */
+    timeout: 60,
+
+    /**
+     * Number of retry attempts
+     */
+    retries: ${tries},
+
+    /**
+     * Delay between retries in seconds
+     */
+    retryAfter: [60, 120, 300],
+  }
+
+  /**
+   * Execute the job
+   * @param payload - The job payload data
+   */
+  public static async handle(payload?: Record<string, unknown>): Promise<{ success: boolean }> {
+    try {
+      log.info('${name}: Starting job execution')
+
+      // Add your job logic here.
+      console.log('Processing with payload:', payload)
+
+      log.info('${name}: Job completed successfully')
+
+      return { success: true }
+    }
+    catch (error) {
+      log.error('${name}: Job failed:', error)
+      throw error
+    }
+  }
+}
+`;
+}

package/dist/make-policy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create a new policy file in app/Policies
+ */
+export declare function makePolicy(options: MakePolicyOptions): Promise<boolean>;
+export declare interface MakePolicyOptions {
+  name?: string
+  model?: string
+  register?: boolean
+  [key: string]: any
+}

package/dist/make-policy.js

@@ -0,0 +1,142 @@
+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
+
+/**
+ * ${policyName}
+ *
+ * This policy controls authorization for ${modelName} model actions.
+ *
+ * Usage:
+ * 1. Register in app/Gates.ts:
+ *    policies: { '${modelName}': '${policyName}' }
+ *
+ * 2. Use in your code:
+ *    import { Gate } from '@stacksjs/auth'
+ *    await Gate.authorize('view', user, ${modelName.toLowerCase()})
+ *
+ * 3. Or use the middleware:
+ *    route.put('/${modelName.toLowerCase()}s/:${modelName.toLowerCase()}', 'Update${modelName}')
+ *      .middleware('can:update,${modelName.toLowerCase()}')
+ */
+
+// TODO: Import or define your ${modelName} type
+interface ${modelName} {
+  id: number
+  user_id: number
+  // Add your model properties here
+}
+
+export default class ${policyName} extends BasePolicy<${modelName}> {
+  /**
+   * Run before any other checks.
+   * Return true to allow, false to deny, null to continue.
+   */
+  before(user: UserModel | null, ability: string): boolean | null {
+    // Example: Admins can do anything
+    // if (user?.role === 'admin') return true
+    return null
+  }
+
+  /**
+   * Determine if the user can view any ${modelName.toLowerCase()}s.
+   */
+  viewAny(user: UserModel | null): boolean {
+    return true
+  }
+
+  /**
+   * Determine if the user can view the ${modelName.toLowerCase()}.
+   */
+  view(user: UserModel | null, model: ${modelName}): boolean {
+    return true
+  }
+
+  /**
+   * Determine if the user can create ${modelName.toLowerCase()}s.
+   */
+  create(user: UserModel | null): boolean {
+    return user !== null
+  }
+
+  /**
+   * Determine if the user can update the ${modelName.toLowerCase()}.
+   */
+  update(user: UserModel | null, model: ${modelName}): boolean {
+    return user?.id === model.user_id
+  }
+
+  /**
+   * Determine if the user can delete the ${modelName.toLowerCase()}.
+   */
+  delete(user: UserModel | null, model: ${modelName}): boolean {
+    return user?.id === model.user_id
+  }
+
+  /**
+   * Determine if the user can restore the ${modelName.toLowerCase()}.
+   */
+  restore(user: UserModel | null, model: ${modelName}): boolean {
+    return user?.id === model.user_id
+  }
+
+  /**
+   * Determine if the user can permanently delete the ${modelName.toLowerCase()}.
+   */
+  forceDelete(user: UserModel | null, model: ${modelName}): boolean {
+    return user?.id === model.user_id
+  }
+}
+`;
+}
+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.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create a new API resource file in app/Resources
+ */
+export declare function makeResource(options: MakeResourceOptions): Promise<boolean>;
+export declare interface MakeResourceOptions {
+  name?: string
+  model?: string
+  collection?: boolean
+  [key: string]: any
+}

package/dist/make-resource.js

@@ -0,0 +1,142 @@
+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'
+
+/**
+ * ${resourceName}
+ *
+ * Transforms ${modelName} model data for API responses.
+ *
+ * @example
+ * // Single resource
+ * return new ${resourceName}(${modelName.toLowerCase()}).toResponse()
+ *
+ * // Collection
+ * return ${resourceName}.collection(${modelName.toLowerCase()}s).toResponse()
+ *
+ * // With additional data
+ * return new ${resourceName}(${modelName.toLowerCase()})
+ *   .withAdditional({ message: 'Success' })
+ *   .toResponse()
+ */
+
+// TODO: Import or define your ${modelName} type
+interface ${modelName} {
+  id: number
+  name: string
+  created_at: Date
+  updated_at: Date
+  // Add your model properties here
+}
+
+export default class ${resourceName} extends JsonResource<${modelName}> {
+  /**
+   * Transform the resource into an array.
+   */
+  toArray(request?: Request): Record<string, any> {
+    return {
+      id: this.resource.id,
+      name: this.resource.name,
+
+      // Conditional fields
+      // secret: this.when(request?.user?.isAdmin, this.resource.secret),
+
+      // Loaded relationships
+      // posts: this.whenLoaded('posts', () =>
+      //   PostResource.collection(this.resource.posts)
+      // ),
+
+      // Relationship counts
+      // posts_count: this.whenCounted('posts'),
+
+      // Timestamps
+      created_at: this.resource.created_at,
+      updated_at: this.resource.updated_at,
+    }
+  }
+}
+`;
+}
+function generateCollectionResourceContent(resourceName, modelName) {
+  const baseResourceName = resourceName.replace("Collection", "");
+  return `import type { Request } from '@stacksjs/router'
+import { JsonResource, ResourceCollection } from '@stacksjs/api'
+
+/**
+ * ${resourceName}
+ *
+ * Collection resource for ${modelName} with custom collection behavior.
+ *
+ * @example
+ * return new ${resourceName}(${modelName.toLowerCase()}s).toResponse()
+ */
+
+// TODO: Import or define your ${modelName} type
+interface ${modelName} {
+  id: number
+  name: string
+  created_at: Date
+  updated_at: Date
+}
+
+/**
+ * Individual resource for the collection
+ */
+class ${baseResourceName} extends JsonResource<${modelName}> {
+  toArray(request?: Request): Record<string, any> {
+    return {
+      id: this.resource.id,
+      name: this.resource.name,
+      created_at: this.resource.created_at,
+      updated_at: this.resource.updated_at,
+    }
+  }
+}
+
+/**
+ * Collection resource with custom behavior
+ */
+export default class ${resourceName} extends ResourceCollection<${modelName}, ${baseResourceName}> {
+  constructor(resources: ${modelName}[]) {
+    super(resources, ${baseResourceName})
+  }
+
+  /**
+   * Add collection-level data to the response
+   */
+  toResponse(request?: Request): Record<string, any> {
+    return {
+      ...super.toResponse(request),
+      meta: {
+        total: this.count(),
+        // Add any collection-level metadata here
+      },
+    }
+  }
+}
+`;
+}

package/dist/make.d.ts

@@ -0,0 +1,52 @@
+import type { MakeOptions } from '@stacksjs/types';
+/**
+ * Toggle dry-run mode. The buddy CLI flips this on before invoking a
+ * scaffolder when the user passed `--dry-run`. Stays a module-level
+ * flag (rather than threading through every signature) so existing
+ * scaffolders can opt in just by switching their write call.
+ */
+export declare function setDryRun(enabled: boolean): void;
+export declare function isDryRunActive(): boolean;
+export declare function invoke(options: MakeOptions): Promise<void>;
+export declare function make(options: MakeOptions): Promise<void>;
+export declare function makeAction(options: MakeOptions): Promise<void>;
+export declare function makeComponent(options: MakeOptions): Promise<void>;
+export declare function createAction(options: MakeOptions): Promise<void>;
+export declare function createComponent(options: MakeOptions): Promise<void>;
+export declare function makeDatabase(options: MakeOptions): void;
+export declare function createDatabase(options: MakeOptions): void;
+export declare function factory(options: MakeOptions): void;
+export declare function createFactory(options: MakeOptions): Promise<void>;
+export declare function makeNotification(options: MakeOptions): Promise<void>;
+/**
+ * Scaffold a Mailable + companion stx template
+ * (stacksjs/stacks#1899, A2 from #1904). Pairs:
+ *
+ *   app/Mail/<PascalName>.ts          ← Mailable subclass
+ *   resources/emails/<kebab-name>.stx ← stx template the Mailable resolves
+ *
+ * The name flows through both files: PascalCase for the class, kebab-case
+ * for the template (matching the convention the framework's bundled
+ * emails use — `welcome.stx`, `password-reset.stx`, etc.).
+ *
+ * Idempotent — refuses to overwrite either file when it already exists
+ * unless `options.force` is true. The reason: an accidental
+ * `buddy make:mail Welcome` against a project that already has a
+ * customized `Welcome` mailable would silently nuke the customization
+ * otherwise.
+ */
+export declare function createMail(options: MakeOptions & { force?: boolean }): Promise<boolean>;
+export declare function makeMail(options: MakeOptions & { force?: boolean }): Promise<void>;
+export declare function makePage(options: MakeOptions): Promise<void>;
+export declare function createPage(options: MakeOptions): Promise<void>;
+export declare function makeFunction(options: MakeOptions): Promise<void>;
+export declare function createFunction(options: MakeOptions): Promise<void>;
+export declare function makeLanguage(options: MakeOptions): Promise<void>;
+export declare function createLanguage(options: MakeOptions): Promise<void>;
+export declare function makeStack(options: MakeOptions): Promise<void>;
+export declare function createNotification(options: MakeOptions): Promise<boolean>;
+export declare function createMigration(options: MakeOptions): Promise<void>;
+export declare function makeQueueTable(): Promise<void>;
+export declare function makeCertificate(): Promise<void>;
+export declare function createModel(options: MakeOptions): Promise<void>;
+export declare function createMiddleware(options: MakeOptions): Promise<void>;