@avada-falcon/worker-sdk 0.5.0

package/src/admin/getQueueDepths.js

@@ -0,0 +1,66 @@
+import {Queue} from 'bullmq';
+import {queueName} from '../queue/queues.js';
+import {withTimeout} from './withTimeout.js';
+
+/**
+ * Get BullMQ queue depths for the given tiers.
+ *
+ * Returns one entry per tier with `{ok, ...counts, total}`. A failure on one
+ * tier does not abort the others — that tier's entry becomes
+ * `{ok: false, error}` and the rest still report their counts.
+ *
+ * Creates short-lived Queue instances and closes them before returning.
+ * If `connection` is an ioredis instance, BullMQ reuses it; the instance is
+ * not closed by this helper.
+ *
+ * @param {object|import('ioredis').Redis} connection - ioredis client OR connection options
+ * @param {string[]} tiers - tier names (e.g. ['heavy', 'medium', 'light'])
+ * @param {object} [options]
+ * @param {number} [options.timeoutMs=5000] - Per-tier timeout for getJobCounts
+ * @returns {Promise<Record<string, {ok: boolean, waiting?, active?, delayed?, completed?, failed?, paused?, total?, error?: string}>>}
+ */
+export async function getQueueDepths(connection, tiers, {timeoutMs = 5000} = {}) {
+  if (!Array.isArray(tiers) || tiers.length === 0) {
+    return {};
+  }
+
+  const queues = tiers.map(tier => ({
+    tier,
+    queue: new Queue(queueName(tier), {connection})
+  }));
+
+  try {
+    const settled = await Promise.allSettled(
+      queues.map(async ({queue}) => {
+        const counts = await withTimeout(
+          queue.getJobCounts(
+            'waiting',
+            'active',
+            'delayed',
+            'completed',
+            'failed',
+            'paused'
+          ),
+          timeoutMs
+        );
+        const total =
+          (counts.waiting || 0) +
+          (counts.active || 0) +
+          (counts.delayed || 0) +
+          (counts.paused || 0);
+        return {ok: true, ...counts, total};
+      })
+    );
+
+    const out = {};
+    settled.forEach((r, i) => {
+      const tier = tiers[i];
+      out[tier] = r.status === 'fulfilled'
+        ? r.value
+        : {ok: false, error: r.reason?.message || String(r.reason)};
+    });
+    return out;
+  } finally {
+    await Promise.all(queues.map(({queue}) => queue.close().catch(() => {})));
+  }
+}

package/src/admin/listWorkers.js

@@ -0,0 +1,44 @@
+import {HEARTBEAT_KEY_PREFIX} from '../worker/heartbeatKey.js';
+
+/**
+ * List all currently-alive workers by scanning heartbeat keys in Redis.
+ * Keys with missing or malformed values are skipped silently.
+ *
+ * @param {object} redis - ioredis client (needs scan, mget)
+ * @returns {Promise<Array<{workerId, hostname, pid, tiers, startedAt, lastBeat}>>}
+ */
+export async function listWorkers(redis) {
+  const keys = await scanAll(redis, `${HEARTBEAT_KEY_PREFIX}*`);
+  if (keys.length === 0) return [];
+
+  const values = await redis.mget(...keys);
+  const workers = [];
+  for (const v of values) {
+    if (v === null || v === undefined) continue;
+    try {
+      const parsed = JSON.parse(v);
+      if (parsed && typeof parsed === 'object' && typeof parsed.workerId === 'string') {
+        workers.push(parsed);
+      }
+      // else: malformed shape — skip silently like malformed JSON
+    } catch {
+      // malformed entry — skip
+    }
+  }
+  return workers;
+}
+
+/**
+ * Iterate SCAN cursor until complete, collecting all matched keys.
+ * Uses SCAN (not KEYS) so this is safe to call on large Redis instances.
+ */
+async function scanAll(redis, pattern) {
+  const keys = [];
+  let cursor = '0';
+  do {
+    const [next, batch] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+    for (const k of batch) keys.push(k);
+    cursor = next;
+  } while (cursor !== '0');
+  return keys;
+}

package/src/admin/pingRedis.js

@@ -0,0 +1,29 @@
+import {withTimeout} from './withTimeout.js';
+
+/**
+ * Ping Redis and measure round-trip latency.
+ *
+ * Never throws on transient failures (timeout, connection error, unexpected
+ * reply) — returns a structured `{ok: false, error}` instead.
+ *
+ * @param {object} redis - ioredis client
+ * @param {object} [options]
+ * @param {number} [options.timeoutMs=2000] - Reject if PING doesn't return in time
+ * @returns {Promise<{ok: boolean, latencyMs: number, error?: string}>}
+ */
+export async function pingRedis(redis, {timeoutMs = 2000} = {}) {
+  if (!redis || typeof redis.ping !== 'function') {
+    return {ok: false, latencyMs: 0, error: 'redis client is required'};
+  }
+  const start = Date.now();
+  try {
+    const result = await withTimeout(redis.ping(), timeoutMs);
+    const latencyMs = Date.now() - start;
+    if (result !== 'PONG') {
+      return {ok: false, latencyMs, error: `unexpected response: ${result}`};
+    }
+    return {ok: true, latencyMs};
+  } catch (err) {
+    return {ok: false, latencyMs: Date.now() - start, error: err.message};
+  }
+}

package/src/admin/withTimeout.js

@@ -0,0 +1,21 @@
+/**
+ * Race a promise against a timeout. The timer never keeps the process alive
+ * (unref) and is always cleared once the race settles.
+ * Shared by the admin probes (pingRedis, getQueueDepths, getClusterHealth).
+ *
+ * Note: this does NOT cancel the underlying operation — checkDashboard uses
+ * AbortController instead because fetch supports real cancellation.
+ *
+ * @param {Promise} promise
+ * @param {number} ms
+ * @returns {Promise<*>} Resolves/rejects with the promise, or rejects with
+ *   `timeout after <ms>ms` if the timeout wins.
+ */
+export function withTimeout(promise, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+    timer.unref?.();
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}

package/src/client/client.js

@@ -0,0 +1,39 @@
+import {randomUUID} from 'crypto';
+import {loadConfig} from '../config/loader.js';
+import {QueuePool, buildJobOpts, DEFAULT_TIER} from '../queue/queues.js';
+
+/**
+ * Create a lightweight job-pushing client.
+ * Reads YAML config for job-to-tier mapping. Lazily creates BullMQ queues.
+ *
+ * @param {string} configPath - Path to worker YAML config
+ * @returns {{add: Function, close: Function}}
+ */
+export function createClient(configPath) {
+  const config = loadConfig(configPath);
+  const pool = new QueuePool(config.redis);
+  const optsCache = new Map(); // job opts are static per job name — build once
+
+  return {
+    async add(jobName, payload) {
+      const jobConfig = config.jobs[jobName];
+      if (!jobConfig) {
+        throw new Error(`Unknown job: ${jobName}. Define it in your worker config.`);
+      }
+
+      const queue = pool.get(jobConfig.tier || DEFAULT_TIER);
+      if (!optsCache.has(jobName)) {
+        optsCache.set(jobName, buildJobOpts(jobConfig));
+      }
+
+      return queue.add(jobName, payload, {
+        ...optsCache.get(jobName),
+        jobId: `${jobName}-${randomUUID()}`
+      });
+    },
+
+    async close() {
+      await pool.closeAll();
+    }
+  };
+}

package/src/config/loader.js

@@ -0,0 +1,178 @@
+import {readFileSync} from 'fs';
+import yaml from 'js-yaml';
+
+const DEFAULT_CONCURRENCY = {heavy: 2, medium: 5, light: 10};
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 10000;
+const DEFAULT_HEARTBEAT_TTL_MS = 30000;
+
+/**
+ * Load and parse YAML config with environment variable interpolation.
+ * @param {string} configPath - Path to the YAML config file
+ * @returns {object} Parsed config
+ */
+export function loadConfig(configPath) {
+  const raw = readFileSync(configPath, 'utf-8');
+  const interpolated = interpolateEnv(raw);
+  const loaded = yaml.load(interpolated);
+  // Empty/comments-only YAML parses to undefined; a scalar isn't a usable config.
+  // Fall through to the redis validation below for a helpful error.
+  const config = loaded && typeof loaded === 'object' ? loaded : {};
+
+  config.concurrency = {...DEFAULT_CONCURRENCY, ...config.concurrency};
+  config.dashboard = config.dashboard || {};
+  config.jobs = config.jobs || {};
+
+  config.worker = config.worker || {};
+  config.cron = config.cron || {};
+
+  normalizeRedisOptions(config.redis);
+  normalizeLokiOptions(config.logging);
+  normalizeWorkerOptions(config.worker);
+  normalizeCronOptions(config.cron);
+
+  // Validate Redis config exists after normalization
+  if (!config.redis || (!config.redis.host && !config.redis.port)) {
+    throw new Error(
+      'worker.config.yml: redis config is required. Set redis.host/port in YAML or via REDIS_HOST/REDIS_PORT env vars.'
+    );
+  }
+
+  return config;
+}
+
+/**
+ * Coerce obj[key] from string to integer in place (env vars are always
+ * strings). Throws on non-numeric strings; leaves non-string values
+ * (already numbers, or absent) untouched.
+ */
+function coerceInt(obj, key, label) {
+  if (typeof obj[key] !== 'string') return;
+  const parsed = parseInt(obj[key], 10);
+  if (Number.isNaN(parsed)) throw new Error(`Invalid ${label}: "${obj[key]}"`);
+  obj[key] = parsed;
+}
+
+/**
+ * Coerce a boolean config value that may arrive as a string env var.
+ * Strict: only 'true'/true and 'false'/false are recognized; anything else
+ * (including typos like "yes"/"1") gets the default — be explicit in config.
+ */
+function coerceBool(value, defaultValue) {
+  if (value === 'true' || value === true) return true;
+  if (value === 'false' || value === false) return false;
+  return defaultValue;
+}
+
+/**
+ * Normalize Redis connection options after env interpolation.
+ * - Strip empty/null fields (when env var is unset, YAML parses ${VAR:-} as null)
+ * - Coerce port from string to number (env vars are always strings)
+ * - Convert tls: "true" to {} (enables TLS); empty/null/false removes the key
+ */
+function normalizeRedisOptions(redis) {
+  if (!redis) return;
+
+  // Drop empty/null fields so they don't override ioredis defaults
+  for (const key of Object.keys(redis)) {
+    if (redis[key] === null || redis[key] === '' || redis[key] === undefined) {
+      delete redis[key];
+    }
+  }
+
+  coerceInt(redis, 'port', 'redis.port');
+
+  // 'false'/false → no TLS; 'true'/true → {} (enables TLS)
+  if (redis.tls === 'false' || redis.tls === false) {
+    delete redis.tls;
+  } else if (redis.tls === 'true' || redis.tls === true) {
+    redis.tls = {};
+  }
+  // If redis.tls is already an object, leave it alone (advanced TLS config)
+}
+
+/**
+ * Normalize logging.loki options after env interpolation.
+ * - Remove loki block entirely if url is empty (keeps SDK in file-only mode).
+ * - Coerce batchSize and flushInterval from string to number (env vars are always strings).
+ * - Apply defaults: batchSize=100, flushInterval=5000.
+ */
+function normalizeLokiOptions(logging) {
+  if (!logging || !logging.loki) return;
+
+  const loki = logging.loki;
+
+  // Empty url = Loki disabled
+  if (!loki.url) {
+    delete logging.loki;
+    return;
+  }
+
+  coerceInt(loki, 'batchSize', 'loki.batchSize');
+  coerceInt(loki, 'flushInterval', 'loki.flushInterval');
+
+  // Defaults (use ?? to preserve valid 0 / false values)
+  loki.batchSize = loki.batchSize ?? 100;
+  loki.flushInterval = loki.flushInterval ?? 5000;
+  loki.labels = loki.labels ?? {};
+}
+
+/**
+ * Normalize worker options after env interpolation.
+ * - Apply heartbeat defaults (enabled=true, intervalMs=10000, ttlMs=30000)
+ * - Coerce intervalMs/ttlMs from string to number
+ * - Coerce enabled from string to boolean
+ * - Validate intervalMs < ttlMs (else key expires between beats)
+ */
+function normalizeWorkerOptions(worker) {
+  worker.heartbeat = worker.heartbeat || {};
+  const hb = worker.heartbeat;
+
+  hb.enabled = coerceBool(hb.enabled, true);
+
+  coerceInt(hb, 'intervalMs', 'worker.heartbeat.intervalMs');
+  hb.intervalMs = hb.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+
+  coerceInt(hb, 'ttlMs', 'worker.heartbeat.ttlMs');
+  hb.ttlMs = hb.ttlMs ?? DEFAULT_HEARTBEAT_TTL_MS;
+
+  if (hb.intervalMs <= 0) {
+    throw new Error(
+      `worker.heartbeat.intervalMs must be > 0 (got ${hb.intervalMs}); ` +
+      'a 0 or negative interval would tight-loop or never fire'
+    );
+  }
+  if (hb.ttlMs <= 0) {
+    throw new Error(
+      `worker.heartbeat.ttlMs must be > 0 (got ${hb.ttlMs}); ` +
+      'a 0 or negative TTL would expire the key immediately'
+    );
+  }
+
+  if (hb.intervalMs >= hb.ttlMs) {
+    throw new Error(
+      `worker.heartbeat.intervalMs (${hb.intervalMs}) must be less than ttlMs (${hb.ttlMs}); ` +
+      'otherwise the heartbeat key expires between beats'
+    );
+  }
+}
+
+/**
+ * Normalize cron options after env interpolation.
+ * - Coerce leader from string to boolean; default false
+ */
+function normalizeCronOptions(cron) {
+  cron.leader = coerceBool(cron.leader, false);
+}
+
+/**
+ * Replace ${VAR_NAME} with process.env.VAR_NAME.
+ * Supports default values: ${VAR_NAME:-default_value}
+ */
+function interpolateEnv(str) {
+  return str.replace(/\$\{(\w+)(?::-([^}]*))?\}/g, (match, varName, defaultValue) => {
+    const value = process.env[varName];
+    if (value !== undefined) return value;
+    if (defaultValue !== undefined) return defaultValue;
+    return match;
+  });
+}

package/src/cron/cronManager.js

@@ -0,0 +1,35 @@
+import {QueuePool, buildJobOpts, DEFAULT_TIER} from '../queue/queues.js';
+
+export class CronManager {
+  constructor(redisOpts) {
+    this._pool = new QueuePool(redisOpts);
+  }
+
+  async register(jobs, {leader = false} = {}) {
+    // cfg may be null for empty YAML mapping values (`jobs: {myJob:}`)
+    const cronJobs = Object.entries(jobs).filter(([, cfg]) => cfg?.cron);
+
+    if (cronJobs.length === 0) return;
+
+    if (!leader) {
+      console.warn(
+        `[worker-sdk] cron.leader=false — skipping registration of ${cronJobs.length} cron job(s). ` +
+        `One worker in the pool must set cron.leader=true to register schedules.`
+      );
+      return;
+    }
+
+    // Upserts are independent (distinct scheduler ids) — run them concurrently
+    await Promise.all(cronJobs.map(([jobName, jobConfig]) =>
+      this._pool.get(jobConfig.tier || DEFAULT_TIER).upsertJobScheduler(
+        jobName,
+        {pattern: jobConfig.cron},
+        {name: jobName, opts: buildJobOpts(jobConfig)}
+      )
+    ));
+  }
+
+  async closeAll() {
+    await this._pool.closeAll();
+  }
+}

package/src/dashboard/server.js

@@ -0,0 +1,79 @@
+import express from 'express';
+import {timingSafeEqual} from 'node:crypto';
+import {createBullBoard} from '@bull-board/api';
+import {BullMQAdapter} from '@bull-board/api/bullMQAdapter';
+import {ExpressAdapter} from '@bull-board/express';
+
+/**
+ * Constant-time buffer comparison (length differences still short-circuit,
+ * which is standard practice for basic-auth checks).
+ */
+function safeEqual(bufA, bufB) {
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+
+/**
+ * Create Express app with Bull Board and health endpoint.
+ * @param {object} options
+ * @param {import('bullmq').Queue[]} options.queues - BullMQ queues to display
+ * @param {object} options.auth - {username, password} for basic auth
+ * @returns {import('express').Express}
+ */
+export function createDashboardApp({queues, auth}) {
+  const app = express();
+
+  // Health endpoint (no auth)
+  const startTime = Date.now();
+  app.get('/health', (req, res) => {
+    res.json({
+      status: 'ok',
+      uptime: Math.floor((Date.now() - startTime) / 1000),
+      timestamp: new Date().toISOString()
+    });
+  });
+
+  // Basic auth for all other routes
+  if (auth?.username && auth?.password) {
+    const expectedUser = Buffer.from(String(auth.username));
+    const expectedPass = Buffer.from(String(auth.password));
+
+    app.use((req, res, next) => {
+      if (req.path === '/health') return next();
+
+      const header = req.headers.authorization;
+      if (!header || !header.startsWith('Basic ')) {
+        res.set('WWW-Authenticate', 'Basic realm="Worker Dashboard"');
+        return res.status(401).send('Authentication required');
+      }
+
+      const credentials = Buffer.from(header.slice(6), 'base64').toString();
+      // Split on the FIRST colon only — RFC 7617 allows colons in the password
+      const sep = credentials.indexOf(':');
+      const username = sep === -1 ? credentials : credentials.slice(0, sep);
+      const password = sep === -1 ? '' : credentials.slice(sep + 1);
+
+      const userOk = safeEqual(Buffer.from(username), expectedUser);
+      const passOk = safeEqual(Buffer.from(password), expectedPass);
+      if (userOk && passOk) {
+        return next();
+      }
+
+      res.set('WWW-Authenticate', 'Basic realm="Worker Dashboard"');
+      return res.status(401).send('Invalid credentials');
+    });
+  }
+
+  // Bull Board
+  const serverAdapter = new ExpressAdapter();
+  serverAdapter.setBasePath('/');
+
+  createBullBoard({
+    queues: queues.map(q => new BullMQAdapter(q)),
+    serverAdapter
+  });
+
+  app.use('/', serverAdapter.getRouter());
+
+  return app;
+}

package/src/dashboard/standalone.js

@@ -0,0 +1,67 @@
+import {Queue} from 'bullmq';
+import {loadConfig} from '../config/loader.js';
+import {queueName} from '../queue/queues.js';
+
+/**
+ * Create a standalone Bull Board dashboard server.
+ * Reads Redis + dashboard config from YAML, serves Bull Board on its own port.
+ *
+ * Usage:
+ *   const dashboard = createDashboard('./worker.config.yml');
+ *   await dashboard.start();
+ *
+ * @param {string} configPath - Path to worker YAML config
+ * @returns {{start: Function, stop: Function, server: import('http').Server|null}}
+ */
+export function createDashboard(configPath) {
+  const config = loadConfig(configPath);
+
+  if (!config.dashboard || config.dashboard.port === undefined) {
+    throw new Error('worker.config.yml: dashboard config is required for standalone dashboard.');
+  }
+
+  const redisOpts = {...config.redis, maxRetriesPerRequest: null};
+
+  const queues = Object.keys(config.concurrency).map(tier =>
+    new Queue(queueName(tier), {connection: redisOpts})
+  );
+
+  if (!config.dashboard.auth?.username || !config.dashboard.auth?.password) {
+    console.warn('[worker-sdk] WARNING: Standalone dashboard running without authentication!');
+  }
+
+  let app = null;
+  let server = null;
+
+  return {
+    get server() {
+      return server;
+    },
+    async start() {
+      if (!app) {
+        // Lazy-load so importing the SDK doesn't pull in express/bull-board
+        // for consumers that never run the dashboard
+        const {createDashboardApp} = await import('./server.js');
+        app = createDashboardApp({queues, auth: config.dashboard.auth});
+      }
+      return new Promise((resolve, reject) => {
+        server = app.listen(config.dashboard.port);
+        server.once('error', async (err) => {
+          await Promise.all(queues.map(q => q.close().catch(() => {})));
+          reject(err);
+        });
+        server.once('listening', () => {
+          console.info(`[worker-sdk] Standalone dashboard running on port ${server.address().port}`);
+          resolve();
+        });
+      });
+    },
+    async stop() {
+      if (server) {
+        await new Promise(resolve => server.close(resolve));
+        server = null;
+      }
+      await Promise.all(queues.map(q => q.close()));
+    }
+  };
+}

package/src/index.cjs

@@ -0,0 +1,18 @@
+// CJS wrapper for environments that can't use ESM (e.g. Babel-compiled code).
+// Each export lazily imports only its own module and forwards all arguments,
+// so signatures never go stale and unused subsystems are never loaded.
+const wrap = (path, name) => async (...args) => {
+  const mod = await import(path);
+  return mod[name](...args);
+};
+
+module.exports = {
+  createWorker: wrap('./worker/worker.js', 'createWorker'),
+  createClient: wrap('./client/client.js', 'createClient'),
+  createDashboard: wrap('./dashboard/standalone.js', 'createDashboard'),
+  listWorkers: wrap('./admin/listWorkers.js', 'listWorkers'),
+  pingRedis: wrap('./admin/pingRedis.js', 'pingRedis'),
+  getQueueDepths: wrap('./admin/getQueueDepths.js', 'getQueueDepths'),
+  checkDashboard: wrap('./admin/checkDashboard.js', 'checkDashboard'),
+  getClusterHealth: wrap('./admin/getClusterHealth.js', 'getClusterHealth')
+};

package/src/index.js

@@ -0,0 +1,8 @@
+export {createWorker} from './worker/worker.js';
+export {createClient} from './client/client.js';
+export {createDashboard} from './dashboard/standalone.js';
+export {listWorkers} from './admin/listWorkers.js';
+export {pingRedis} from './admin/pingRedis.js';
+export {getQueueDepths} from './admin/getQueueDepths.js';
+export {checkDashboard} from './admin/checkDashboard.js';
+export {getClusterHealth} from './admin/getClusterHealth.js';

package/src/logging/fileLogger.js

@@ -0,0 +1,77 @@
+import {mkdirSync, appendFileSync, readdirSync, unlinkSync, statSync} from 'fs';
+import {join} from 'path';
+
+/**
+ * File logger that writes structured JSON lines to daily log files.
+ * Thread-safe via appendFileSync (atomic append on most OS).
+ */
+export class FileLogger {
+  /**
+   * @param {object} options
+   * @param {string} options.dir - Directory to write log files
+   * @param {number} [options.retentionDays=30] - Delete log files older than this
+   */
+  constructor({dir, retentionDays = 30}) {
+    this._dir = dir;
+    this._retentionDays = retentionDays;
+
+    mkdirSync(dir, {recursive: true});
+  }
+
+  /**
+   * Write a log entry to today's file.
+   * @param {object} entry - {job, id, level, msg, data}
+   */
+  write(entry) {
+    const now = new Date();
+    const filename = `${formatDate(now)}.log`;
+    const filepath = join(this._dir, filename);
+
+    try {
+      // Stringify inside the try — unserializable entry.data (circular, BigInt)
+      // must not crash the worker either
+      const line = JSON.stringify({
+        ts: now.toISOString(),
+        job: entry.job,
+        id: entry.id,
+        level: entry.level,
+        msg: entry.msg,
+        ...(entry.data ? {data: entry.data} : {})
+      }) + '\n';
+      appendFileSync(filepath, line);
+    } catch (err) {
+      // Don't crash the worker if log write fails
+      process.stderr.write(`[worker-sdk] Failed to write log file: ${err.message}\n`);
+    }
+  }
+
+  /**
+   * Delete log files older than retentionDays.
+   */
+  cleanup() {
+    if (!this._retentionDays) return;
+
+    const cutoff = Date.now() - this._retentionDays * 24 * 60 * 60 * 1000;
+
+    try {
+      const files = readdirSync(this._dir).filter(f => f.endsWith('.log'));
+
+      for (const file of files) {
+        const filepath = join(this._dir, file);
+        const stat = statSync(filepath);
+        if (stat.mtimeMs < cutoff) {
+          unlinkSync(filepath);
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`[worker-sdk] Log cleanup failed: ${err.message}\n`);
+    }
+  }
+}
+
+function formatDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}