@hasna/shortlinks 0.1.23 → 0.2.0

package/dist/pg-store.d.ts

@@ -1,3 +1,4 @@
+import type { TypedQueryClient } from "./generated/storage-kit/query.js";
 import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
 type PgAdapterLike = {
     get(sql: string, ...params: unknown[]): Promise<any>;
@@ -5,14 +6,24 @@ type PgAdapterLike = {
     run(sql: string, ...params: unknown[]): Promise<unknown>;
     close?: () => Promise<void>;
 };
-export interface PgConnectionOptions {
-    ssl?: boolean;
-}
+/**
+ * Adapt a vendored storage-kit `TypedQueryClient` (which speaks `$1` positional
+ * params) to the `?`-placeholder `PgAdapterLike` the store queries are written
+ * against. This lets `shortlinks-serve` reuse the exact same SQL as the CLI while
+ * opening its cloud pool through the sanctioned kit (`createCloudPoolFromEnv`).
+ */
+export declare function createKitPgAdapter(client: TypedQueryClient): PgAdapterLike;
 export declare class PgShortlinksStore {
     private readonly pg;
     constructor(pg: PgAdapterLike);
-    static fromConnectionString(connectionString: string, options?: PgConnectionOptions): Promise<PgShortlinksStore>;
-    static fromEnv(env?: NodeJS.ProcessEnv): Promise<PgShortlinksStore>;
+    /**
+     * Build a store over a vendored storage-kit query client. This is the ONLY
+     * constructor: the serve entrypoint opens its pool via `createCloudPoolFromEnv`
+     * (server-side) and hands the client here. There is deliberately no
+     * DSN-from-env / connection-string path so this store can never be misused to
+     * open the raw RDS from a client.
+     */
+    static fromQueryClient(client: TypedQueryClient): PgShortlinksStore;
     close(): Promise<void>;
     addDomain(input: AddDomainInput): Promise<Domain>;
     listDomains(): Promise<Domain[]>;
@@ -38,9 +49,4 @@ export declare class PgShortlinksStore {
     private hashIp;
     private generateAvailableSlug;
 }
-export declare function applyPostgresMigrations(connectionString: string, migrations: string[], options?: PgConnectionOptions): Promise<{
-    service: "shortlinks";
-    applied: number[];
-    skipped: number[];
-}>;
 export {};

package/dist/pg-store.js

@@ -1,4 +1,37 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
 // src/pg-store.ts
 import { createHash } from "crypto";
 
@@ -17,9 +50,19 @@ function ensureDataDir() {
   mkdirSync(dir, { recursive: true });
   return dir;
 }
+function getConfigPath() {
+  return join(ensureDataDir(), "config.json");
+}
 function getClickSaltPath() {
   return join(ensureDataDir(), "click-salt");
 }
+function getDatabasePath(explicitPath) {
+  if (explicitPath)
+    return resolve(explicitPath);
+  if (process.env.SHORTLINKS_DB)
+    return resolve(process.env.SHORTLINKS_DB);
+  return join(ensureDataDir(), `${SERVICE_NAME}.db`);
+}
 function readClickSaltFile(path) {
   try {
     const saved = readFileSync(path, "utf-8").trim();
@@ -65,6 +108,35 @@ function getClickSalt() {
     throw clickSaltError(path, error);
   }
 }
+function loadConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const path = getConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+function updateConfig(patch) {
+  const next = {
+    ...loadConfig(),
+    ...patch,
+    cloudflare: {
+      ...loadConfig().cloudflare,
+      ...patch.cloudflare
+    }
+  };
+  saveConfig(next);
+  return next;
+}
 function normalizeHostname(input) {
   const raw = input.trim().toLowerCase();
   if (!raw)
@@ -93,6 +165,9 @@ function formatShortUrl(hostname, slug, publicBaseUrl) {
 }
 
 // src/database.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 function now() {
   return new Date().toISOString();
 }
@@ -101,6 +176,105 @@ function makeId(prefix) {
   const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
   return `${prefix}_${hex}`;
 }
+var SQLITE_MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS domains (
+    id TEXT PRIMARY KEY,
+    hostname TEXT NOT NULL UNIQUE,
+    provider TEXT NOT NULL DEFAULT 'manual',
+    default_domain INTEGER NOT NULL DEFAULT 0,
+    cloudflare_zone_id TEXT,
+    cloudflare_account_id TEXT,
+    cloudflare_worker_name TEXT,
+    origin_url TEXT,
+    notes TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    machine_id TEXT,
+    synced_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS links (
+    id TEXT PRIMARY KEY,
+    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    slug TEXT NOT NULL,
+    destination_url TEXT NOT NULL,
+    title TEXT,
+    active INTEGER NOT NULL DEFAULT 1,
+    expires_at TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    machine_id TEXT,
+    synced_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(domain_id, slug)
+  );
+
+  CREATE TABLE IF NOT EXISTS clicks (
+    id TEXT PRIMARY KEY,
+    link_id TEXT NOT NULL REFERENCES links(id) ON DELETE CASCADE,
+    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    slug TEXT NOT NULL,
+    clicked_at TEXT NOT NULL,
+    ip_hash TEXT,
+    user_agent TEXT,
+    referer TEXT,
+    country TEXT,
+    city TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    machine_id TEXT,
+    synced_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_domains_hostname ON domains(hostname);
+  CREATE INDEX IF NOT EXISTS idx_domains_default ON domains(default_domain);
+  CREATE INDEX IF NOT EXISTS idx_links_domain_slug ON links(domain_id, slug);
+  CREATE INDEX IF NOT EXISTS idx_links_active ON links(active);
+  CREATE INDEX IF NOT EXISTS idx_links_updated ON links(updated_at);
+  CREATE INDEX IF NOT EXISTS idx_clicks_link ON clicks(link_id);
+  CREATE INDEX IF NOT EXISTS idx_clicks_domain ON clicks(domain_id);
+  CREATE INDEX IF NOT EXISTS idx_clicks_clicked_at ON clicks(clicked_at);
+  CREATE INDEX IF NOT EXISTS idx_clicks_updated ON clicks(updated_at);
+  `
+];
+
+class ShortlinksDatabase {
+  db;
+  path;
+  constructor(path) {
+    this.path = getDatabasePath(path);
+    mkdirSync2(dirname2(this.path), { recursive: true });
+    this.db = new Database(this.path);
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.applyMigrations();
+  }
+  close() {
+    this.db.close();
+  }
+  applyMigrations() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS _migrations (
+        id INTEGER PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      );
+    `);
+    for (let i = 0;i < SQLITE_MIGRATIONS.length; i += 1) {
+      const id = i + 1;
+      const applied = this.db.query("SELECT id FROM _migrations WHERE id = ?").get(id);
+      if (applied)
+        continue;
+      const migration = SQLITE_MIGRATIONS[i];
+      const apply = this.db.transaction(() => {
+        this.db.exec(migration);
+        this.db.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(id, now());
+      });
+      apply();
+    }
+  }
+}
 
 // src/machine.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -146,46 +320,6 @@ function getMachineId() {
   return id;
 }
 
-// src/runtime.ts
-var SHORTLINKS_RUNTIME_ENV = {
-  store: "HASNA_SHORTLINKS_STORE",
-  databaseUrl: "HASNA_SHORTLINKS_DATABASE_URL",
-  databaseSsl: "HASNA_SHORTLINKS_DATABASE_SSL"
-};
-var SHORTLINKS_RUNTIME_FALLBACK_ENV = {
-  store: "SHORTLINKS_STORE",
-  databaseUrl: "SHORTLINKS_DATABASE_URL",
-  databaseSsl: "SHORTLINKS_DATABASE_SSL"
-};
-function getShortlinksDatabaseUrl(env = process.env) {
-  return readRuntimeEnv(env, "databaseUrl").value;
-}
-function getShortlinksDatabaseSsl(env = process.env) {
-  return parseBoolean(readRuntimeEnv(env, "databaseSsl").value, true);
-}
-function readRuntimeEnv(env, key) {
-  const primary = SHORTLINKS_RUNTIME_ENV[key];
-  const primaryValue = clean(env[primary]);
-  if (primaryValue)
-    return { name: primary, value: primaryValue };
-  const fallback = SHORTLINKS_RUNTIME_FALLBACK_ENV[key];
-  return { name: fallback, value: clean(env[fallback]) };
-}
-function parseBoolean(value, fallback) {
-  const normalized = clean(value)?.toLowerCase();
-  if (!normalized)
-    return fallback;
-  if (["1", "true", "yes", "on"].includes(normalized))
-    return true;
-  if (["0", "false", "no", "off"].includes(normalized))
-    return false;
-  throw new Error(`${SHORTLINKS_RUNTIME_ENV.databaseSsl} must be true or false`);
-}
-function clean(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
-
 // src/pg-store.ts
 function parseJsonObject(value) {
   if (!value)
@@ -199,47 +333,10 @@ function parseJsonObject(value) {
     return {};
   }
 }
-async function loadPgPool() {
-  const importer = new Function("specifier", "return import(specifier)");
-  const module = await importer("pg");
-  return module.Pool;
-}
 function toPostgresSql(sql) {
   let index = 0;
   return sql.replace(/\?/g, () => `$${++index}`);
 }
-function createPgPoolConfig(connectionString, options = {}) {
-  const ssl = options.ssl ?? true;
-  return {
-    connectionString,
-    ...ssl ? { ssl: { rejectUnauthorized: true } } : { ssl: false }
-  };
-}
-
-class PgPoolAdapter {
-  pool;
-  constructor(pool) {
-    this.pool = pool;
-  }
-  static async create(connectionString, options = {}) {
-    const Pool = await loadPgPool();
-    return new PgPoolAdapter(new Pool(createPgPoolConfig(connectionString, options)));
-  }
-  async get(sql, ...params) {
-    const result = await this.pool.query(toPostgresSql(sql), params);
-    return result.rows[0] ?? null;
-  }
-  async all(sql, ...params) {
-    const result = await this.pool.query(toPostgresSql(sql), params);
-    return result.rows;
-  }
-  async run(sql, ...params) {
-    return this.pool.query(toPostgresSql(sql), params);
-  }
-  async close() {
-    await this.pool.end();
-  }
-}
 function toIsoString(value) {
   if (value instanceof Date)
     return value.toISOString();
@@ -302,21 +399,27 @@ function clickFromRow(row) {
     metadata: parseJsonObject(row.metadata)
   };
 }
+function createKitPgAdapter(client) {
+  return {
+    async get(sql, ...params) {
+      return client.get(toPostgresSql(sql), params);
+    },
+    async all(sql, ...params) {
+      return client.many(toPostgresSql(sql), params);
+    },
+    async run(sql, ...params) {
+      return client.query(toPostgresSql(sql), params);
+    }
+  };
+}
 
 class PgShortlinksStore {
   pg;
   constructor(pg) {
     this.pg = pg;
   }
-  static async fromConnectionString(connectionString, options = {}) {
-    return new PgShortlinksStore(await PgPoolAdapter.create(connectionString, options));
-  }
-  static async fromEnv(env = process.env) {
-    const connectionString = getShortlinksDatabaseUrl(env);
-    if (!connectionString) {
-      throw new Error("HASNA_SHORTLINKS_DATABASE_URL is required when shortlinks uses the postgres store");
-    }
-    return PgShortlinksStore.fromConnectionString(connectionString, { ssl: getShortlinksDatabaseSsl(env) });
+  static fromQueryClient(client) {
+    return new PgShortlinksStore(createKitPgAdapter(client));
   }
   async close() {
     await this.pg.close?.();
@@ -546,53 +649,7 @@ class PgShortlinksStore {
     throw new Error("Could not generate an unused slug after 32 attempts.");
   }
 }
-async function applyPostgresMigrations(connectionString, migrations, options = {}) {
-  const Pool = await loadPgPool();
-  const pool = new Pool(createPgPoolConfig(connectionString, options));
-  const client = await pool.connect();
-  const run = (sql, ...params) => client.query(toPostgresSql(sql), params);
-  const get = async (sql, ...params) => {
-    const result = await run(sql, ...params);
-    return result.rows[0] ?? null;
-  };
-  const applied = [];
-  const skipped = [];
-  try {
-    await run("BEGIN");
-    await run(`
-      SELECT pg_advisory_xact_lock(hashtext(?))
-    `, "shortlinks:migrations");
-    await run(`
-      CREATE TABLE IF NOT EXISTS _shortlinks_migrations (
-        id INTEGER PRIMARY KEY,
-        service TEXT NOT NULL DEFAULT 'shortlinks',
-        applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
-      )
-    `);
-    for (let i = 0;i < migrations.length; i += 1) {
-      const id = i + 1;
-      const existing = await get("SELECT id FROM _shortlinks_migrations WHERE id = ? LIMIT 1", id);
-      if (existing) {
-        skipped.push(id);
-        continue;
-      }
-      await run(migrations[i]);
-      await run("INSERT INTO _shortlinks_migrations (id, service, applied_at) VALUES (?, ?, now())", id, "shortlinks");
-      applied.push(id);
-    }
-    await run("COMMIT");
-    return { service: "shortlinks", applied, skipped };
-  } catch (error) {
-    try {
-      await run("ROLLBACK");
-    } catch {}
-    throw error;
-  } finally {
-    client.release();
-    await pool.end();
-  }
-}
 export {
-  applyPostgresMigrations,
+  createKitPgAdapter,
   PgShortlinksStore
 };

package/dist/sdk/generated.d.ts

@@ -0,0 +1,178 @@
+export interface Link {
+    "id": string;
+    "domain_id": string;
+    "hostname": string;
+    "slug": string;
+    "destination_url": string;
+    "title"?: string | null;
+    "active": boolean;
+    "expires_at"?: string | null;
+    "short_url"?: string;
+    "metadata"?: Record<string, unknown>;
+    "created_at": string;
+    "updated_at"?: string;
+}
+export interface Domain {
+    "id": string;
+    "hostname": string;
+    "provider": string;
+    "default_domain": boolean;
+    "origin_url"?: string | null;
+    "notes"?: string | null;
+    "metadata"?: Record<string, unknown>;
+    "created_at": string;
+    "updated_at"?: string;
+}
+export interface LinkStats {
+    "link": Link;
+    "clicks": number;
+    "last_clicked_at"?: string | null;
+    "top_referrers"?: Array<{
+        "referer"?: string | null;
+        "clicks"?: number;
+    }>;
+    "top_user_agents"?: Array<{
+        "user_agent"?: string | null;
+        "clicks"?: number;
+    }>;
+}
+export type LinkList = Array<{
+    "id": string;
+    "domain_id": string;
+    "hostname": string;
+    "slug": string;
+    "destination_url": string;
+    "title"?: string | null;
+    "active": boolean;
+    "expires_at"?: string | null;
+    "short_url"?: string;
+    "metadata"?: Record<string, unknown>;
+    "created_at": string;
+    "updated_at"?: string;
+}>;
+export type DomainList = Array<{
+    "id": string;
+    "hostname": string;
+    "provider": string;
+    "default_domain": boolean;
+    "origin_url"?: string | null;
+    "notes"?: string | null;
+    "metadata"?: Record<string, unknown>;
+    "created_at": string;
+    "updated_at"?: string;
+}>;
+export interface TotalStats {
+    "domains": number;
+    "links": number;
+    "clicks": number;
+}
+export interface CreateLinkRequest {
+    "url": string;
+    "domain"?: string;
+    "slug"?: string;
+    "title"?: string;
+    "expires_at"?: string;
+    "length"?: number;
+    "metadata"?: Record<string, unknown>;
+}
+export interface AddDomainRequest {
+    "hostname": string;
+    "provider"?: string;
+    "default"?: boolean;
+    "origin_url"?: string;
+    "notes"?: string;
+    "metadata"?: Record<string, unknown>;
+}
+export interface DeleteResponse {
+    "deleted": boolean;
+    "slug"?: string;
+}
+export interface HealthStatus {
+    "status": string;
+    "version": string;
+    "mode": string;
+    "db_latency_ms"?: number;
+}
+export interface ReadyStatus {
+    "status": string;
+    "version": string;
+    "mode": string;
+    "pending_migrations"?: Array<string>;
+}
+export interface VersionInfo {
+    "status": string;
+    "version": string;
+    "mode": string;
+    "name"?: string;
+}
+export interface ErrorResponse {
+    "error": string;
+    "reason"?: string;
+}
+export interface ShortlinksApiClientOptions {
+    /** Base URL, e.g. process.env.APP_API_URL. */
+    baseUrl: string;
+    /** API key, e.g. process.env.APP_API_KEY. Sent as the 'x-api-key' header. */
+    apiKey?: string;
+    /** Custom fetch (defaults to global fetch). */
+    fetch?: typeof fetch;
+    /** Extra headers merged into every request. */
+    headers?: Record<string, string>;
+}
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, message: string, body: unknown);
+}
+export declare class ShortlinksApiClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    private readonly baseHeaders;
+    constructor(options: ShortlinksApiClientOptions);
+    private request;
+    /** Liveness probe. */
+    getHealth(init?: RequestInit): Promise<HealthStatus>;
+    /** Readiness probe (DB reachable and schema migrated). */
+    getReady(init?: RequestInit): Promise<ReadyStatus>;
+    /** List configured domains. */
+    listDomains(init?: RequestInit): Promise<DomainList>;
+    /** Add or update a domain. */
+    addDomain(body: AddDomainRequest, init?: RequestInit): Promise<Domain>;
+    /** List shortlinks. */
+    listLinks(query?: {
+        "domain"?: string;
+        "active"?: boolean;
+        "limit"?: number;
+    }, init?: RequestInit): Promise<LinkList>;
+    /** Create a shortlink. */
+    createLink(body: CreateLinkRequest, init?: RequestInit): Promise<Link>;
+    /** Get a shortlink by slug. */
+    getLink(slug: string, query?: {
+        "domain"?: string;
+    }, init?: RequestInit): Promise<Link>;
+    /** Delete a shortlink. */
+    deleteLink(slug: string, query?: {
+        "domain"?: string;
+    }, init?: RequestInit): Promise<DeleteResponse>;
+    /** Disable a shortlink. */
+    disableLink(slug: string, query?: {
+        "domain"?: string;
+    }, init?: RequestInit): Promise<Link>;
+    /** Enable a shortlink. */
+    enableLink(slug: string, query?: {
+        "domain"?: string;
+    }, init?: RequestInit): Promise<Link>;
+    /** Click stats for a shortlink. */
+    getLinkStats(slug: string, query?: {
+        "domain"?: string;
+    }, init?: RequestInit): Promise<LinkStats>;
+    /** Resolve a slug to its destination without recording a click. */
+    resolveLink(slug: string, query?: {
+        "domain"?: string;
+    }, init?: RequestInit): Promise<Link>;
+    /** Total domains/links/clicks counts. */
+    getStats(init?: RequestInit): Promise<TotalStats>;
+    /** Service version and mode. */
+    getVersion(init?: RequestInit): Promise<VersionInfo>;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hasna/shortlinks/sdk — typed client for the shortlinks REST API.
+ *
+ * The generated client (`ShortlinksApiClient`) is produced from the serve
+ * OpenAPI document (src/serve/openapi.ts) by `bun run sdk:generate`. It is the
+ * canonical client for the versioned `/v1` API with API-key auth.
+ *
+ * Client self_hosted mode reads `SHORTLINKS_API_URL` + `SHORTLINKS_API_KEY`
+ * (never a DSN).
+ */
+export * from "./generated.js";
+export { buildOpenApiDocument } from "../serve/openapi.js";