@primstack/cli 0.0.1

package/dist/integrations/queue/providers/memory/templates/src/queue/index.ts.template

@@ -0,0 +1,73 @@
+import { EventEmitter } from 'events';
+import type { JobOptions, JobHandler } from './types.js';
+
+interface QueuedJob<T = unknown> {
+  id: string;
+  name: string;
+  data: T;
+  options: JobOptions;
+  attempts: number;
+}
+
+const emitter = new EventEmitter();
+const handlers = new Map<string, JobHandler<unknown>>();
+const timers = new Set<ReturnType<typeof setTimeout>>();
+let jobCounter = 0;
+
+export async function addJob<T = unknown>(
+  name: string,
+  data: T,
+  options?: JobOptions,
+): Promise<string> {
+  const id = `job_${++jobCounter}`;
+  const job: QueuedJob<T> = {
+    id,
+    name,
+    data,
+    options: options ?? {},
+    attempts: 0,
+  };
+
+  const delay = options?.delay ?? 0;
+  const timer = setTimeout(() => {
+    timers.delete(timer);
+    emitter.emit(name, job);
+  }, delay);
+  timers.add(timer);
+
+  return id;
+}
+
+export async function registerWorker<T = unknown>(
+  name: string,
+  handler: JobHandler<T>,
+): Promise<void> {
+  handlers.set(name, handler as JobHandler<unknown>);
+  emitter.on(name, async (job: QueuedJob<T>) => {
+    const maxAttempts = job.options.attempts ?? 3;
+    const backoff = job.options.backoff ?? 1000;
+
+    while (job.attempts < maxAttempts) {
+      try {
+        job.attempts++;
+        await handler(job.data);
+        return;
+      } catch (err) {
+        if (job.attempts >= maxAttempts) {
+          console.error(`[queue] Job ${job.id} (${name}) failed after ${maxAttempts} attempts:`, err);
+          return;
+        }
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+    }
+  });
+}
+
+export async function stopAll(): Promise<void> {
+  for (const timer of timers) clearTimeout(timer);
+  timers.clear();
+  emitter.removeAllListeners();
+  handlers.clear();
+}
+
+export type { JobOptions, JobHandler } from './types.js';

package/dist/integrations/queue/providers/memory/templates/src/queue/types.ts.template

@@ -0,0 +1,10 @@
+export interface JobOptions {
+  delay?: number;     // ms before job becomes processable
+  attempts?: number;  // max retry attempts (default: 3)
+  backoff?: number;   // ms between retries
+  priority?: number;  // lower = higher priority
+}
+
+export interface JobHandler<T = unknown> {
+  (data: T): Promise<void>;
+}

package/dist/integrations/queue/providers/pgboss/templates/src/queue/index.ts.template

@@ -0,0 +1,34 @@
+import PgBoss from 'pg-boss';
+import type { JobOptions, JobHandler } from './types.js';
+
+export const boss = new PgBoss(process.env.DATABASE_URL || 'postgresql://localhost:5432/mydb');
+
+export async function startBoss(): Promise<void> {
+  await boss.start();
+}
+
+export async function addJob<T extends object = object>(
+  name: string,
+  data: T,
+  options?: JobOptions,
+): Promise<string | null> {
+  return boss.send(name, data, {
+    startAfter: options?.delay ? new Date(Date.now() + options.delay) : undefined,
+    retryLimit: options?.attempts ?? 3,
+    retryDelay: options?.backoff ? options.backoff / 1000 : undefined,
+    priority: options?.priority,
+  });
+}
+
+export async function registerWorker<T extends object = object>(
+  name: string,
+  handler: JobHandler<T>,
+): Promise<void> {
+  await boss.work(name, async (job) => handler(job.data as T));
+}
+
+export async function stopBoss(): Promise<void> {
+  await boss.stop();
+}
+
+export type { JobOptions, JobHandler } from './types.js';

package/dist/integrations/queue/providers/pgboss/templates/src/queue/types.ts.template

@@ -0,0 +1,10 @@
+export interface JobOptions {
+  delay?: number;     // ms before job becomes processable
+  attempts?: number;  // max retry attempts (default: 3)
+  backoff?: number;   // ms between retries
+  priority?: number;  // lower = higher priority
+}
+
+export interface JobHandler<T = unknown> {
+  (data: T): Promise<void>;
+}

package/dist/integrations/ratelimit/providers/memory/templates/src/ratelimit/index.ts.template

@@ -0,0 +1,95 @@
+import type { RateLimiterOptions, RateLimitResult } from './types.js';
+
+export type { RateLimiterOptions, RateLimitResult } from './types.js';
+
+interface WindowEntry {
+  count: number;
+  resetAt: number;
+}
+
+export interface RateLimiter {
+  points: number;
+  duration: number;
+  store: Map<string, WindowEntry>;
+}
+
+/**
+ * Create a rate limiter instance.
+ * Defaults: 10 requests per 1 second window.
+ */
+export function createRateLimiter(options?: Partial<RateLimiterOptions>): RateLimiter {
+  return {
+    points: options?.points ?? 10,
+    duration: options?.duration ?? 1,
+    store: new Map(),
+  };
+}
+
+function getEntry(limiter: RateLimiter, key: string): WindowEntry {
+  const now = Date.now();
+  const entry = limiter.store.get(key);
+
+  if (!entry || now >= entry.resetAt) {
+    const newEntry: WindowEntry = {
+      count: 0,
+      resetAt: now + limiter.duration * 1000,
+    };
+    limiter.store.set(key, newEntry);
+    return newEntry;
+  }
+
+  return entry;
+}
+
+/**
+ * Consume points from the rate limiter for the given key.
+ */
+export async function limit(
+  limiter: RateLimiter,
+  key: string,
+  points?: number,
+): Promise<RateLimitResult> {
+  const entry = getEntry(limiter, key);
+  const cost = points ?? 1;
+
+  if (entry.count + cost > limiter.points) {
+    return {
+      allowed: false,
+      remaining: Math.max(0, limiter.points - entry.count),
+      limit: limiter.points,
+      resetMs: entry.resetAt - Date.now(),
+    };
+  }
+
+  entry.count += cost;
+
+  return {
+    allowed: true,
+    remaining: limiter.points - entry.count,
+    limit: limiter.points,
+    resetMs: entry.resetAt - Date.now(),
+  };
+}
+
+/**
+ * Check rate limit status without consuming a point.
+ */
+export async function check(
+  limiter: RateLimiter,
+  key: string,
+): Promise<RateLimitResult> {
+  const entry = getEntry(limiter, key);
+  return {
+    allowed: entry.count < limiter.points,
+    remaining: Math.max(0, limiter.points - entry.count),
+    limit: limiter.points,
+    resetMs: entry.resetAt - Date.now(),
+  };
+}
+
+/**
+ * Reset the rate limit for a given key.
+ */
+export async function reset(limiter: RateLimiter, key: string): Promise<void> {
+  limiter.store.delete(key);
+}

package/dist/integrations/ratelimit/providers/memory/templates/src/ratelimit/types.ts.template

@@ -0,0 +1,12 @@
+export interface RateLimiterOptions {
+  points: number;
+  duration: number;
+  blockDuration?: number;
+}
+
+export interface RateLimitResult {
+  allowed: boolean;
+  remaining: number;
+  limit: number;
+  resetMs: number;
+}

package/dist/integrations/ratelimit/providers/rate-limiter-flexible/templates/src/ratelimit/index.ts.template

@@ -0,0 +1,80 @@
+import { RateLimiterMemory } from 'rate-limiter-flexible';
+import type { RateLimiterOptions, RateLimitResult } from './types.js';
+
+export type { RateLimiterOptions, RateLimitResult } from './types.js';
+
+export type RateLimiter = RateLimiterMemory;
+
+/**
+ * Create a rate limiter instance.
+ * Defaults: 10 requests per 1 second window.
+ */
+export function createRateLimiter(options?: Partial<RateLimiterOptions>): RateLimiter {
+  const points = options?.points ?? 10;
+  const duration = options?.duration ?? 1;
+  const blockDuration = options?.blockDuration ?? 0;
+
+  return new RateLimiterMemory({
+    points,
+    duration,
+    blockDuration,
+  });
+}
+
+/**
+ * Consume points from the rate limiter for the given key.
+ */
+export async function limit(
+  limiter: RateLimiter,
+  key: string,
+  points?: number,
+): Promise<RateLimitResult> {
+  try {
+    const res = await limiter.consume(key, points ?? 1);
+    return {
+      allowed: true,
+      remaining: res.remainingPoints,
+      limit: limiter.points,
+      resetMs: res.msBeforeNext,
+    };
+  } catch (rej: unknown) {
+    const res = rej as { remainingPoints: number; msBeforeNext: number };
+    return {
+      allowed: false,
+      remaining: res.remainingPoints,
+      limit: limiter.points,
+      resetMs: res.msBeforeNext,
+    };
+  }
+}
+
+/**
+ * Check rate limit status without consuming a point.
+ */
+export async function check(
+  limiter: RateLimiter,
+  key: string,
+): Promise<RateLimitResult> {
+  const res = await limiter.get(key);
+  if (!res) {
+    return {
+      allowed: true,
+      remaining: limiter.points,
+      limit: limiter.points,
+      resetMs: 0,
+    };
+  }
+  return {
+    allowed: res.remainingPoints >= 0,
+    remaining: res.remainingPoints,
+    limit: limiter.points,
+    resetMs: res.msBeforeNext,
+  };
+}
+
+/**
+ * Reset the rate limit for a given key.
+ */
+export async function reset(limiter: RateLimiter, key: string): Promise<void> {
+  await limiter.delete(key);
+}

package/dist/integrations/ratelimit/providers/rate-limiter-flexible/templates/src/ratelimit/types.ts.template

@@ -0,0 +1,12 @@
+export interface RateLimiterOptions {
+  points: number;
+  duration: number;
+  blockDuration?: number;
+}
+
+export interface RateLimitResult {
+  allowed: boolean;
+  remaining: number;
+  limit: number;
+  resetMs: number;
+}

package/dist/integrations/ratelimit/providers/upstash/templates/src/ratelimit/index.ts.template

@@ -0,0 +1,67 @@
+import { Ratelimit } from '@upstash/ratelimit';
+import { Redis } from '@upstash/redis';
+import type { RateLimiterOptions, RateLimitResult } from './types.js';
+
+export type { RateLimiterOptions, RateLimitResult } from './types.js';
+
+export type RateLimiter = Ratelimit;
+
+const redis = new Redis({
+  url: process.env.UPSTASH_REDIS_REST_URL!,
+  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
+});
+
+/**
+ * Create a rate limiter instance.
+ * Defaults: 10 requests per 1 second sliding window.
+ */
+export function createRateLimiter(options?: Partial<RateLimiterOptions>): RateLimiter {
+  const points = options?.points ?? 10;
+  const duration = options?.duration ?? 1;
+
+  return new Ratelimit({
+    redis,
+    limiter: Ratelimit.slidingWindow(points, `${duration} s`),
+  });
+}
+
+/**
+ * Consume points from the rate limiter for the given key.
+ * Note: Upstash ratelimit consumes 1 token per call; the points parameter is ignored.
+ */
+export async function limit(
+  limiter: RateLimiter,
+  key: string,
+  _points?: number,
+): Promise<RateLimitResult> {
+  const res = await limiter.limit(key);
+  return {
+    allowed: res.success,
+    remaining: res.remaining,
+    limit: res.limit,
+    resetMs: Math.max(0, res.reset - Date.now()),
+  };
+}
+
+/**
+ * Check rate limit status without consuming a point.
+ */
+export async function check(
+  limiter: RateLimiter,
+  key: string,
+): Promise<RateLimitResult> {
+  const res = await limiter.getRemaining(key);
+  return {
+    allowed: res.remaining > 0,
+    remaining: res.remaining,
+    limit: 0,
+    resetMs: Math.max(0, res.reset - Date.now()),
+  };
+}
+
+/**
+ * Reset the rate limit for a given key.
+ */
+export async function reset(limiter: RateLimiter, key: string): Promise<void> {
+  await limiter.resetUsedTokens(key);
+}

package/dist/integrations/ratelimit/providers/upstash/templates/src/ratelimit/types.ts.template

@@ -0,0 +1,12 @@
+export interface RateLimiterOptions {
+  points: number;
+  duration: number;
+  blockDuration?: number;
+}
+
+export interface RateLimitResult {
+  allowed: boolean;
+  remaining: number;
+  limit: number;
+  resetMs: number;
+}

package/dist/integrations/schedule/providers/bullmq/templates/src/schedule/index.ts.template

@@ -0,0 +1,81 @@
+import { Queue, Worker, type Job } from 'bullmq';
+import IORedis from 'ioredis';
+import type { ScheduledJob, SchedulerOptions } from './types.js';
+
+const redisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
+const connection = new IORedis(redisUrl, { maxRetriesPerRequest: null });
+
+const QUEUE_NAME = 'scheduled-jobs';
+const queue = new Queue(QUEUE_NAME, { connection });
+
+const handlers = new Map<string, () => void | Promise<void>>();
+let worker: Worker | null = null;
+
+function ensureWorker(): void {
+  if (worker) return;
+
+  worker = new Worker(
+    QUEUE_NAME,
+    async (job: Job) => {
+      const handler = handlers.get(job.name);
+      if (handler) {
+        await handler();
+      }
+    },
+    { connection },
+  );
+}
+
+export async function scheduleJob(
+  name: string,
+  cronExpr: string,
+  handler: () => void | Promise<void>,
+  options?: SchedulerOptions,
+): Promise<void> {
+  if (handlers.has(name)) {
+    throw new Error(`Job '${name}' is already scheduled`);
+  }
+
+  handlers.set(name, handler);
+  ensureWorker();
+
+  await queue.upsertJobScheduler(
+    name,
+    { pattern: cronExpr, ...(options?.timezone ? { tz: options.timezone } : {}) },
+    { name },
+  );
+
+  if (options?.runOnInit) {
+    await queue.add(name, {});
+  }
+}
+
+export async function stopJob(name: string): Promise<void> {
+  if (!handlers.has(name)) {
+    throw new Error(`Job '${name}' not found`);
+  }
+
+  await queue.removeJobScheduler(name);
+  handlers.delete(name);
+}
+
+export async function stopAll(): Promise<void> {
+  for (const name of handlers.keys()) {
+    await queue.removeJobScheduler(name);
+  }
+  handlers.clear();
+
+  if (worker) {
+    await worker.close();
+    worker = null;
+  }
+
+  await queue.close();
+  await connection.quit();
+}
+
+export function listJobs(): string[] {
+  return Array.from(handlers.keys());
+}
+
+export type { ScheduledJob, SchedulerOptions } from './types.js';

package/dist/integrations/schedule/providers/bullmq/templates/src/schedule/types.ts.template

@@ -0,0 +1,10 @@
+export interface ScheduledJob {
+  name: string;
+  schedule: string;
+  handler: () => void | Promise<void>;
+}
+
+export interface SchedulerOptions {
+  timezone?: string;
+  runOnInit?: boolean;
+}

package/dist/integrations/schedule/providers/croner/templates/src/schedule/index.ts.template

@@ -0,0 +1,47 @@
+import { Cron } from 'croner';
+import type { ScheduledJob, SchedulerOptions } from './types.js';
+
+const jobs = new Map<string, Cron>();
+
+export function scheduleJob(
+  name: string,
+  cronExpr: string,
+  handler: () => void | Promise<void>,
+  options?: SchedulerOptions,
+): void {
+  if (jobs.has(name)) {
+    throw new Error(`Job '${name}' is already scheduled`);
+  }
+
+  const job = new Cron(cronExpr, {
+    timezone: options?.timezone,
+  }, handler);
+
+  if (options?.runOnInit) {
+    job.trigger();
+  }
+
+  jobs.set(name, job);
+}
+
+export function stopJob(name: string): void {
+  const job = jobs.get(name);
+  if (!job) {
+    throw new Error(`Job '${name}' not found`);
+  }
+  job.stop();
+  jobs.delete(name);
+}
+
+export function stopAll(): void {
+  for (const [name, job] of jobs) {
+    job.stop();
+    jobs.delete(name);
+  }
+}
+
+export function listJobs(): string[] {
+  return Array.from(jobs.keys());
+}
+
+export type { ScheduledJob, SchedulerOptions } from './types.js';

package/dist/integrations/schedule/providers/croner/templates/src/schedule/types.ts.template

@@ -0,0 +1,10 @@
+export interface ScheduledJob {
+  name: string;
+  schedule: string;
+  handler: () => void | Promise<void>;
+}
+
+export interface SchedulerOptions {
+  timezone?: string;
+  runOnInit?: boolean;
+}

package/dist/integrations/schedule/providers/node-cron/templates/src/schedule/index.ts.template

@@ -0,0 +1,45 @@
+import cron, { type ScheduledTask } from 'node-cron';
+import type { ScheduledJob, SchedulerOptions } from './types.js';
+
+const jobs = new Map<string, ScheduledTask>();
+
+export function scheduleJob(
+  name: string,
+  cronExpr: string,
+  handler: () => void | Promise<void>,
+  options?: SchedulerOptions,
+): void {
+  if (jobs.has(name)) {
+    throw new Error(`Job '${name}' is already scheduled`);
+  }
+
+  const task = cron.schedule(cronExpr, handler, {
+    timezone: options?.timezone,
+    scheduled: true,
+    runOnInit: options?.runOnInit ?? false,
+  });
+
+  jobs.set(name, task);
+}
+
+export function stopJob(name: string): void {
+  const task = jobs.get(name);
+  if (!task) {
+    throw new Error(`Job '${name}' not found`);
+  }
+  task.stop();
+  jobs.delete(name);
+}
+
+export function stopAll(): void {
+  for (const [name, task] of jobs) {
+    task.stop();
+    jobs.delete(name);
+  }
+}
+
+export function listJobs(): string[] {
+  return Array.from(jobs.keys());
+}
+
+export type { ScheduledJob, SchedulerOptions } from './types.js';

package/dist/integrations/schedule/providers/node-cron/templates/src/schedule/types.ts.template

@@ -0,0 +1,10 @@
+export interface ScheduledJob {
+  name: string;
+  schedule: string;
+  handler: () => void | Promise<void>;
+}
+
+export interface SchedulerOptions {
+  timezone?: string;
+  runOnInit?: boolean;
+}

package/dist/integrations/search/providers/algolia/templates/src/search/index.ts.template

@@ -0,0 +1,52 @@
+import { algoliasearch } from 'algoliasearch';
+import type { SearchDocument, SearchOptions, SearchResult } from './types.js';
+
+export const client = algoliasearch(
+  process.env.ALGOLIA_APP_ID || '',
+  process.env.ALGOLIA_API_KEY || '',
+);
+
+export function getIndex(name: string) {
+  return name;
+}
+
+export async function addDocuments<T extends SearchDocument>(
+  indexName: string,
+  documents: T[],
+): Promise<void> {
+  await client.saveObjects({
+    indexName,
+    objects: documents.map((doc) => ({ objectID: String(doc.id), ...doc })),
+  });
+}
+
+export async function search<T extends SearchDocument>(
+  indexName: string,
+  query: string,
+  options?: SearchOptions,
+): Promise<SearchResult<T>> {
+  const result = await client.searchSingleIndex({
+    indexName,
+    searchParams: {
+      query,
+      hitsPerPage: options?.limit ?? 20,
+      page: options?.offset ? Math.floor(options.offset / (options?.limit ?? 20)) : 0,
+      filters: options?.filter,
+    },
+  });
+  return {
+    hits: result.hits as T[],
+    totalHits: result.nbHits ?? result.hits.length,
+    query,
+    processingTimeMs: result.processingTimeMS ?? 0,
+  };
+}
+
+export async function deleteDocuments(
+  indexName: string,
+  ids: (string | number)[],
+): Promise<void> {
+  await client.deleteObjects({ indexName, objectIDs: ids.map(String) });
+}
+
+export type { SearchDocument, SearchOptions, SearchResult } from './types.js';

package/dist/integrations/search/providers/algolia/templates/src/search/types.ts.template

@@ -0,0 +1,18 @@
+export interface SearchDocument {
+  id: string | number;
+  [key: string]: unknown;
+}
+
+export interface SearchOptions {
+  limit?: number;
+  offset?: number;
+  filter?: string;
+  sort?: string[];
+}
+
+export interface SearchResult<T = SearchDocument> {
+  hits: T[];
+  totalHits: number;
+  query: string;
+  processingTimeMs: number;
+}