create-nexgen 1.0.4

package/template/src/env.ts

@@ -0,0 +1,107 @@
+import { config } from "dotenv";
+import { expand } from "dotenv-expand";
+import { z } from "zod";
+
+expand(config({ override: true }));
+
+const envSchema = z
+  .object({
+    APP_NAME: z.string().default("nexgen"),
+    APP_ENV: z.enum(["development", "production", "test"]).default("development"),
+    APP_PORT: z.coerce.number().default(3000),
+    APP_URL: z.string().trim().min(1, "APP_URL is required in .env"),
+    FRONTEND_URL: z.string().optional().transform((value) => value?.trim() || undefined),
+    OPEN_API: z.enum(["true", "false"]).default("true").transform((value) => value === "true"),
+    LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("debug"),
+    CORS_ORIGIN: z.string().default("*"),
+    DATABASE_URL: z.string().default("sqlite:./src/storage/database/nexgen.sqlite"),
+    STORAGE_DRIVER: z.enum(["local", "s3"]).default("local"),
+    STORAGE_DISK: z.enum(["public", "private", "tmp"]).default("public"),
+    STORAGE_BUCKET: z.string().optional().transform((value) => value?.trim() || undefined),
+    STORAGE_REGION: z.string().default("us-east-1"),
+    STORAGE_ENDPOINT: z.string().optional().transform((value) => value?.trim() || undefined),
+    STORAGE_ACCESS_KEY_ID: z.string().optional().transform((value) => value?.trim() || undefined),
+    STORAGE_SECRET_ACCESS_KEY: z.string().optional().transform((value) => value?.trim() || undefined),
+    STORAGE_FORCE_PATH_STYLE: z.enum(["true", "false"]).default("false").transform((value) => value === "true"),
+    STORAGE_SIGNED_URL_TTL_SECONDS: z.coerce.number().default(900),
+    REDIS: z.enum(["true", "false"]).default("false").transform((value) => value === "true"),
+    REDIS_URL: z.string().default("redis://127.0.0.1:6379"),
+    REDIS_PREFIX: z.string().default("nexgen").transform((value) => value.trim()),
+    BULLMQ_UI_ALLOWED_EMAILS: z.string().default(""),
+    SESSION_COOKIE: z.string().default("nexgen_session"),
+    SESSION_TTL_SECONDS: z.coerce.number().default(7200),
+    CACHE_TTL_SECONDS: z.coerce.number().default(3600),
+    SOCKET: z.enum(["true", "false"]).default("true").transform((value) => value === "true"),
+    FRONTEND: z.enum(["true", "false"]).default("true").transform((value) => value === "true"),
+    JWT_ACCESS_SECRET: z.string(),
+    JWT_REFRESH_SECRET: z.string(),
+    JWT_ACCESS_EXPIRY: z.coerce.number().default(900),
+    JWT_REFRESH_EXPIRY: z.coerce.number().default(2592000),
+    JWT_REFRESH_REMEMBER_EXPIRY: z.coerce.number().default(604800),
+    COOKIE_NAME: z.string().default("nexgen"),
+    COOKIE_SECRET: z.string(),
+    REDIS_COMMANDER_PORT: z.coerce.number().default(1369),
+    MAIL_PORT: z.coerce.number().default(1089),
+    MAILDEV_WEB_PORT: z.coerce.number().default(1080),
+    MAIL_HOST: z.string().default("127.0.0.1"),
+    MAIL_USERNAME: z.string().default(""),
+    MAIL_PASSWORD: z.string().default(""),
+    MAIL_FROM_ADDRESS: z.string().default("noreply@nexgen.local"),
+    MAIL_FAIL_SILENT: z.enum(["true", "false"]).default("true").transform((value) => value === "true"),
+    AUTH_REQUIRE_EMAIL_VERIFICATION: z.enum(["true", "false"]).default("false").transform((value) => value === "true"),
+  }).superRefine((data, ctx) => {
+    if (data.STORAGE_DRIVER === "s3") {
+      if (!data.STORAGE_BUCKET) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["STORAGE_BUCKET"],
+          message: "STORAGE_BUCKET is required when STORAGE_DRIVER=s3"
+        });
+      }
+
+      if (!data.STORAGE_ACCESS_KEY_ID) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["STORAGE_ACCESS_KEY_ID"],
+          message: "STORAGE_ACCESS_KEY_ID is required when STORAGE_DRIVER=s3"
+        });
+      }
+
+      if (!data.STORAGE_SECRET_ACCESS_KEY) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["STORAGE_SECRET_ACCESS_KEY"],
+          message: "STORAGE_SECRET_ACCESS_KEY is required when STORAGE_DRIVER=s3"
+        });
+      }
+    }
+
+    for (const key of ["JWT_ACCESS_SECRET", "JWT_REFRESH_SECRET", "COOKIE_SECRET"] as const) {
+      if (!(data as any)[key]) {
+        ctx.addIssue({
+          code: "custom",
+          path: [key],
+          message: `${key} is required`
+        });
+      }
+    }
+
+    if (!data.REDIS) return;
+
+    if (!data.REDIS_PREFIX) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["REDIS_PREFIX"],
+        message: "REDIS_PREFIX is required when REDIS=true"
+      });
+    }
+  });
+
+const parsedEnv = envSchema.parse(process.env);
+
+export const env = {
+  ...parsedEnv,
+  FRONTEND_URL: parsedEnv.FRONTEND_URL
+};
+
+export type Env = typeof env;

package/template/src/framework/cache/cache.ts

@@ -0,0 +1,81 @@
+import { env } from "@/env.js";
+import { redisClientIfReady } from "@/framework/redis/client.js";
+
+function cacheKey(key: string) {
+  return `${env.REDIS_PREFIX}:cache:${key}`;
+}
+
+/**
+ * Why: Provides Redis-backed cache helpers with graceful fallback behavior.
+ * When: Controllers/jobs need temporary computed data caching.
+ * Where: Application module code via facade.
+ * How: Uses namespaced Redis keys and JSON serialization.
+ */
+export const cache = {
+  /**
+   * Why: Reads cached JSON value by key.
+   * When: A feature wants fast lookup before recomputing.
+   * Where: Controllers/jobs/services using shared cache.
+   * How: Fetches namespaced Redis key and parses JSON.
+   */
+  async get<T>(key: string, fallback: T | null = null) {
+    const client = redisClientIfReady();
+    if (!client) return fallback;
+
+    const value = await client.get(cacheKey(key));
+    return value ? (JSON.parse(value) as T) : fallback;
+  },
+
+  /**
+   * Why: Stores value in cache with TTL.
+   * When: Data should be reused for a limited period.
+   * Where: Application code caching expensive results.
+   * How: Serializes value and writes with Redis EX seconds.
+   */
+  async put(key: string, value: unknown, ttl = env.CACHE_TTL_SECONDS) {
+    const client = redisClientIfReady();
+    if (!client) return false;
+
+    await client.set(cacheKey(key), JSON.stringify(value), "EX", ttl);
+    return true;
+  },
+
+  /**
+   * Why: Deletes a cached value by key.
+   * When: Cached data becomes stale or must be invalidated.
+   * Where: Write/update flows that change source data.
+   * How: Removes namespaced Redis cache key.
+   */
+  async forget(key: string) {
+    const client = redisClientIfReady();
+    if (!client) return false;
+
+    await client.del(cacheKey(key));
+    return true;
+  },
+
+  /**
+   * Why: Returns cached value or computes/stores a fresh one.
+   * When: A feature needs cache-aside behavior.
+   * Where: Read paths with potentially expensive callbacks.
+   * How: Attempts get first, then executes callback and put.
+   */
+  async remember<T>(key: string, ttl: number, callback: () => Promise<T>) {
+    const cached = await cache.get<T>(key);
+    if (cached !== null) return cached;
+
+    const fresh = await callback();
+    await this.put(key, fresh, ttl);
+    return fresh;
+  },
+
+  /**
+   * Why: Indicates whether Redis cache backend is currently usable.
+   * When: Runtime checks need to branch on cache availability.
+   * Where: Health/status endpoints and conditional flows.
+   * How: Confirms REDIS flag and ready Redis client instance.
+   */
+  isAvailable() {
+    return env.REDIS && redisClientIfReady() !== null;
+  }
+};

package/template/src/framework/database/connection.ts

@@ -0,0 +1,168 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { env } from "@/env.js";
+import * as schema from "@/database/schema.js";
+
+export type Dialect = "sqlite" | "mysql" | "postgresql";
+
+let databaseInstance: any;
+let pool: any;
+let dialect: Dialect;
+
+/**
+ * Why: Resolves the active DB driver from DATABASE_URL.
+ * When: Called during bootstrap and dialect-specific branching.
+ * Where: Used by init/close and schema generation helpers.
+ * How: Checks DATABASE_URL prefix and maps to sqlite/mysql/postgresql.
+ */
+export function detectDialect(): Dialect {
+  const url = env.DATABASE_URL.toLowerCase();
+  if (url.startsWith("mysql")) return "mysql";
+  if (url.startsWith("postgres")) return "postgresql";
+  return "sqlite";
+}
+
+/**
+ * Why: Creates a singleton Drizzle connection for the current dialect.
+ * When: Called once at app/worker/scheduler startup.
+ * Where: Framework bootstrap entry points.
+ * How: Builds dialect-specific pool/client and stores it in module state.
+ */
+export async function initDatabase() {
+  if (databaseInstance) return databaseInstance;
+
+  dialect = detectDialect();
+
+  if (dialect === "sqlite") {
+    let drizzleSqlite: any;
+    let Database: any;
+    try {
+      [{ drizzle: drizzleSqlite }, { default: Database }] = await Promise.all([
+        import("drizzle-orm/better-sqlite3"),
+        import("better-sqlite3")
+      ]);
+    } catch {
+      throw new Error(
+        "Missing sqlite dependencies. Install with: bun add drizzle-orm better-sqlite3"
+      );
+    }
+
+    const file = path.resolve(process.cwd(), env.DATABASE_URL.replace(/^sqlite:/, ""));
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    pool = new Database(file);
+    pool.pragma("foreign_keys = ON");
+    databaseInstance = drizzleSqlite(pool, { schema });
+    return databaseInstance;
+  }
+
+  if (dialect === "mysql") {
+    let drizzleMysql: any;
+    let mysql: any;
+    try {
+      [{ drizzle: drizzleMysql }, mysql] = await Promise.all([
+        import("drizzle-orm/mysql2"),
+        import("mysql2/promise")
+      ]);
+    } catch {
+      throw new Error("Missing mysql dependencies. Install with: bun add drizzle-orm mysql2");
+    }
+
+    pool = mysql.createPool({ uri: env.DATABASE_URL, connectionLimit: 10, enableKeepAlive: true });
+    databaseInstance = drizzleMysql(pool, { schema, mode: "default" });
+    return databaseInstance;
+  }
+
+  let drizzlePg: any;
+  let PgPool: any;
+  try {
+    [{ drizzle: drizzlePg }, { Pool: PgPool }] = await Promise.all([
+      import("drizzle-orm/node-postgres"),
+      import("pg")
+    ]);
+  } catch {
+    throw new Error("Missing postgres dependencies. Install with: bun add drizzle-orm pg");
+  }
+
+  pool = new PgPool({ connectionString: env.DATABASE_URL });
+  databaseInstance = drizzlePg(pool, { schema });
+  return databaseInstance;
+}
+
+/**
+ * Why: Returns initialized Drizzle instance for queries.
+ * When: Used by app code after bootstrap.
+ * Where: Facade `db` proxy and direct internal consumers.
+ * How: Throws if initDatabase has not completed.
+ */
+export function database() {
+  if (!databaseInstance) throw new Error("Database is not initialized");
+  return databaseInstance;
+}
+
+/**
+ * Why: Exposes low-level pool/client for advanced operations.
+ * When: Needed by internals that require native pool behavior.
+ * Where: Scheduler lock and infrastructure helpers.
+ * How: Returns shared pool and guards against uninitialized access.
+ */
+export function databasePool() {
+  if (!pool) throw new Error("Database pool is not initialized");
+  return pool;
+}
+
+/**
+ * Why: Gracefully closes DB resources during shutdown/reset flows.
+ * When: Server stop, worker stop, migration/reset commands.
+ * Where: Runtime lifecycle scripts.
+ * How: Detects dialect, closes pool, and clears singleton state.
+ */
+export async function closeDatabase() {
+  if (!pool) return;
+
+  const activeDialect = databaseDialect();
+
+  if (activeDialect === "sqlite") {
+    pool.close?.();
+    pool = undefined;
+    databaseInstance = undefined;
+    return;
+  }
+
+  if (activeDialect === "mysql") {
+    await pool.end();
+    pool = undefined;
+    databaseInstance = undefined;
+    return;
+  }
+
+  await pool.end();
+  pool = undefined;
+  databaseInstance = undefined;
+}
+
+/**
+ * Why: Returns active dialect for conditional SQL/runtime behavior.
+ * When: Dialect-specific features are required.
+ * Where: Locking, schema, and shutdown helpers.
+ * How: Uses initialized dialect or falls back to detection.
+ */
+export function databaseDialect() {
+  return dialect || detectDialect();
+}
+
+/**
+ * Why: Provides ergonomic global query surface without calling database().
+ * When: Used by modules, seeders, and facade consumers.
+ * Where: Exposed via framework facade as `db`.
+ * How: Proxy forwards property access to the initialized Drizzle instance.
+ */
+export const db = new Proxy(
+  {},
+  {
+    get(_target, property) {
+      const instance = database();
+      const value = instance[property as keyof typeof instance];
+      return typeof value === "function" ? value.bind(instance) : value;
+    }
+  }
+) as any;

package/template/src/framework/database/optional-db-drivers.d.ts

@@ -0,0 +1,9 @@
+declare module "better-sqlite3" {
+  const Database: any;
+  export default Database;
+}
+
+declare module "pg" {
+  export const Client: any;
+  export const Pool: any;
+}

package/template/src/framework/database/paginate.ts

@@ -0,0 +1,200 @@
+import { count, getTableColumns, type SQL } from "drizzle-orm";
+import { db } from "@/framework/database/connection.js";
+
+type PaginateOptions = {
+  page?: number;
+  perPage?: number;
+  maxPerPage?: number;
+  path?: string;
+  where?: SQL<unknown>;
+  orderBy?: unknown[];
+};
+
+type RequestLike = {
+  req: {
+    query: (key: string) => string | undefined;
+    path: string;
+    url?: string;
+  };
+};
+
+type PaginateQueryOptions<T> = {
+  page?: number;
+  perPage?: number;
+  maxPerPage?: number;
+  path?: string;
+  total: () => Promise<number>;
+  data: (limit: number, offset: number) => Promise<T[]>;
+};
+
+export type PaginatedResult<T> = {
+  current_page: number;
+  data: T[];
+  first_page_url: string | null;
+  from: number | null;
+  last_page: number;
+  last_page_url: string | null;
+  links: Array<{ url: string | null; label: string; page: number | null; active: boolean; }>;
+  next_page_url: string | null;
+  path: string;
+  per_page: number;
+  prev_page_url: string | null;
+  to: number | null;
+  total: number;
+};
+
+function toPositiveInt(value: unknown, fallback: number) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 1) return fallback;
+  return Math.floor(parsed);
+}
+
+function pageUrl(path: string, page: number, perPage: number) {
+  if (!path) return null;
+  const delimiter = path.includes("?") ? "&" : "?";
+  return `${path}${delimiter}page=${page}&per_page=${perPage}`;
+}
+
+/**
+ * Why: Generic paginator for custom total/data callbacks.
+ * When: You need pagination outside direct table helpers.
+ * Where: Controllers/services composing complex queries.
+ * How: Normalizes page params, computes URLs/meta, and executes callbacks.
+ */
+export async function paginateQuery<T = any>(
+  options: PaginateQueryOptions<T>
+): Promise<PaginatedResult<T>> {
+  const maxPerPage = toPositiveInt(options.maxPerPage, 100);
+  const perPage = Math.min(toPositiveInt(options.perPage, 15), maxPerPage);
+  const page = toPositiveInt(options.page, 1);
+
+  const total = Number(await options.total());
+  const lastPage = Math.max(1, Math.ceil(total / perPage));
+  const currentPage = Math.min(page, lastPage);
+  const safeOffset = (currentPage - 1) * perPage;
+  const data = await options.data(perPage, safeOffset);
+
+  const from = total === 0 ? null : safeOffset + 1;
+  const to = total === 0 ? null : safeOffset + data.length;
+  const path = options.path || "";
+  const firstPageUrl = pageUrl(path, 1, perPage);
+  const lastPageUrl = pageUrl(path, lastPage, perPage);
+  const prevPageUrl = currentPage > 1 ? pageUrl(path, currentPage - 1, perPage) : null;
+  const nextPageUrl = currentPage < lastPage ? pageUrl(path, currentPage + 1, perPage) : null;
+
+  const links: Array<{ url: string | null; label: string; page: number | null; active: boolean; }> =
+    [
+      {
+        url: prevPageUrl,
+        label: "&laquo; Previous",
+        page: currentPage > 1 ? currentPage - 1 : null,
+        active: false
+      }
+    ];
+
+  for (let p = 1; p <= lastPage; p += 1) {
+    links.push({
+      url: pageUrl(path, p, perPage),
+      label: String(p),
+      page: p,
+      active: p === currentPage
+    });
+  }
+
+  links.push({
+    url: nextPageUrl,
+    label: "Next &raquo;",
+    page: currentPage < lastPage ? currentPage + 1 : null,
+    active: false
+  });
+
+  return {
+    current_page: currentPage,
+    data,
+    first_page_url: firstPageUrl,
+    from,
+    last_page: lastPage,
+    last_page_url: lastPageUrl,
+    links,
+    next_page_url: nextPageUrl,
+    path,
+    per_page: perPage,
+    prev_page_url: prevPageUrl,
+    to,
+    total
+  };
+}
+
+/**
+ * Why: Paginates a Drizzle query using request query params.
+ * When: Route handlers receive `page/per_page` from client.
+ * Where: API controllers returning list resources.
+ * How: Builds count subquery and applies limit/offset to source query.
+ */
+export async function paginate<T = any>(
+  c: RequestLike,
+  query: any,
+  perPage = 15,
+  options: { maxPerPage?: number; path?: string; } = {}
+): Promise<PaginatedResult<T>> {
+  const page = Number(c.req.query("page") || 1);
+  const size = c.req.query("size");
+  const perPageQuery = c.req.query("per_page");
+  const perPageValue = Number(size || perPageQuery || perPage);
+  const fallbackPath = c.req.path;
+  const resolvedPath = (() => {
+    if (options.path) return options.path;
+    if (!c.req.url) return fallbackPath;
+    try {
+      const parsed = new URL(c.req.url);
+      return `${parsed.origin}${parsed.pathname}`;
+    } catch {
+      return fallbackPath;
+    }
+  })();
+
+  const queryForCount = query.as("paginate_rows");
+
+  return paginateQuery<T>({
+    page,
+    perPage: perPageValue,
+    maxPerPage: options.maxPerPage,
+    path: resolvedPath,
+    total: async () => {
+      const totalRow = await db.select({ total: count() }).from(queryForCount);
+      return Number(totalRow[0]?.total ?? 0);
+    },
+    data: (limit, offset) => query.limit(limit).offset(offset)
+  });
+}
+
+/**
+ * Why: Paginates a full table with optional filters/sorting.
+ * When: CRUD list endpoints need simple table pagination.
+ * Where: Service/controller code for table resources.
+ * How: Runs total + paged select with where/order options.
+ */
+export async function paginateTable<T = any>(
+  db: any,
+  table: any,
+  options: PaginateOptions = {}
+): Promise<PaginatedResult<T>> {
+  return paginateQuery<T>({
+    page: options.page,
+    perPage: options.perPage,
+    maxPerPage: options.maxPerPage,
+    path: options.path,
+    total: async () => {
+      let totalQuery = db.select({ total: count() }).from(table);
+      if (options.where) totalQuery = totalQuery.where(options.where);
+      const totalRow = await totalQuery;
+      return Number(totalRow[0]?.total ?? 0);
+    },
+    data: async (limit, offset) => {
+      let dataQuery = db.select(getTableColumns(table)).from(table);
+      if (options.where) dataQuery = dataQuery.where(options.where);
+      if (options.orderBy?.length) dataQuery = dataQuery.orderBy(...options.orderBy);
+      return dataQuery.limit(limit).offset(offset);
+    }
+  });
+}

package/template/src/framework/database/schema.ts

@@ -0,0 +1,26 @@
+import { detectDialect } from "@/framework/database/connection.js";
+
+/**
+ * Why: Picks dialect-specific model exports from composite schema modules.
+ * When: Building generated schema for active DB dialect.
+ * Where: Maker/database schema generation pipeline.
+ * How: Filters objects containing sqlite/mysql/postgresql keys and selects current dialect.
+ */
+export function normalizeSchemaExports(source: Record<string, any>) {
+  const dialect = detectDialect();
+  const out: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(source)) {
+    if (
+      value &&
+      typeof value === "object" &&
+      "sqlite" in value &&
+      "mysql" in value &&
+      "postgresql" in value
+    ) {
+      out[key] = value[dialect];
+    }
+  }
+
+  return out;
+}

package/template/src/framework/database/seed.ts

@@ -0,0 +1,33 @@
+import { discoverModuleFiles, importFile } from "@/framework/modules/discover.js";
+import { closeDatabase, initDatabase } from "@/framework/database/connection.js";
+
+/**
+ * Why: Runs module seeders for all modules or one targeted module.
+ * When: CLI executes `db:seed` flows.
+ * Where: Framework database seeding runtime.
+ * How: Boots DB, discovers seeder files, executes default exports, then closes DB.
+ */
+await initDatabase();
+
+try {
+  const moduleArg = process.argv.find((arg) => arg.startsWith("--module="));
+  const moduleName = moduleArg?.split("=")[1]?.trim();
+  const pattern = moduleName
+    ? `${moduleName}/database/seeders/*.{ts,js}`
+    : "**/database/seeders/*.{ts,js}";
+
+  const files = await discoverModuleFiles(pattern);
+
+  for (const file of files) {
+    const seeder = await importFile(file);
+    if (typeof seeder.default === "function") {
+      await seeder.default();
+    }
+  }
+
+  console.log(
+    `Executed ${files.length} seeder file(s)${moduleName ? ` for module ${moduleName}` : ""}`
+  );
+} finally {
+  await closeDatabase();
+}

package/template/src/framework/events/dispatcher.ts

@@ -0,0 +1,57 @@
+import { queueJob } from "@/framework/queue/queue.js";
+import { broadcast, type BroadcastOptions } from "@/framework/realtime/broadcast.js";
+
+type CommandHandler = (payload: any) => Promise<any>;
+
+const commandHandlers = new Map<string, CommandHandler>();
+
+/**
+ * Why: Registers in-memory command handler for synchronous dispatch.
+ * When: Module startup files register command handlers.
+ * Where: Job/command style module code.
+ * How: Stores handler in a process-level map by command name.
+ */
+export function command(name: string, handler: CommandHandler) {
+  commandHandlers.set(name, handler);
+}
+
+/**
+ * Why: Executes command immediately or queues it for async processing.
+ * When: Application logic needs command pattern behavior.
+ * Where: Controllers, jobs, and service layers.
+ * How: Runs local handler unless async requested; otherwise enqueues.
+ */
+export async function dispatchCommand(
+  name: string,
+  payload: any,
+  options: { async?: boolean; queue?: string } = {}
+) {
+  if (!options.async) {
+    const handler = commandHandlers.get(name);
+    if (handler) return await handler(payload);
+  }
+
+  return await queueJob(name, payload, { queue: options.queue || "default" });
+}
+
+/**
+ * Why: Dispatches domain events with optional queueing and websocket fan-out.
+ * When: Domain actions need side effects or realtime notifications.
+ * Where: Controllers/jobs across modules.
+ * How: Broadcasts via Socket.IO and optionally enqueues job.
+ */
+export async function dispatchEvent(
+  name: string,
+  payload: any,
+  options: { queue?: boolean | string; broadcast?: BroadcastOptions } = {}
+) {
+  if (options.broadcast) {
+    broadcast(name, payload, options.broadcast);
+  }
+
+  if (options.queue) {
+    return await queueJob(name, payload, {
+      queue: typeof options.queue === "string" ? options.queue : "default"
+    });
+  }
+}