@hasna/shortlinks 0.1.23 → 0.2.0

package/dist/sdk/index.js

@@ -0,0 +1,500 @@
+// @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/sdk/generated.ts
+class ApiError extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+}
+
+class ShortlinksApiClient {
+  baseUrl;
+  apiKey;
+  fetchImpl;
+  baseHeaders;
+  constructor(options) {
+    if (!options.baseUrl)
+      throw new Error("ShortlinksApiClient requires a baseUrl.");
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.baseHeaders = options.headers ?? {};
+  }
+  async request(method, path, opts) {
+    const url = new URL(this.baseUrl + path);
+    if (opts.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        if (value !== undefined && value !== null)
+          url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = { Accept: "application/json", ...this.baseHeaders, ...opts.init?.headers };
+    if (this.apiKey)
+      headers["x-api-key"] = this.apiKey;
+    let payload;
+    if (opts.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      payload = JSON.stringify(opts.body);
+    }
+    const response = await this.fetchImpl(url.toString(), { ...opts.init, method, headers, body: payload });
+    const text = await response.text();
+    const data = text ? (() => {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    })() : undefined;
+    if (!response.ok) {
+      throw new ApiError(response.status, `${method} ${path} failed: ${response.status}`, data);
+    }
+    return data;
+  }
+  async getHealth(init) {
+    return this.request("GET", `/health`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async getReady(init) {
+    return this.request("GET", `/ready`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async listDomains(init) {
+    return this.request("GET", `/v1/domains`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async addDomain(body, init) {
+    return this.request("POST", `/v1/domains`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async listLinks(query, init) {
+    return this.request("GET", `/v1/links`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async createLink(body, init) {
+    return this.request("POST", `/v1/links`, {
+      body,
+      query: undefined,
+      init
+    });
+  }
+  async getLink(slug, query, init) {
+    return this.request("GET", `/v1/links/${encodeURIComponent(String(slug))}`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async deleteLink(slug, query, init) {
+    return this.request("DELETE", `/v1/links/${encodeURIComponent(String(slug))}`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async disableLink(slug, query, init) {
+    return this.request("POST", `/v1/links/${encodeURIComponent(String(slug))}/disable`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async enableLink(slug, query, init) {
+    return this.request("POST", `/v1/links/${encodeURIComponent(String(slug))}/enable`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async getLinkStats(slug, query, init) {
+    return this.request("GET", `/v1/links/${encodeURIComponent(String(slug))}/stats`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async resolveLink(slug, query, init) {
+    return this.request("GET", `/v1/resolve/${encodeURIComponent(String(slug))}`, {
+      body: undefined,
+      query,
+      init
+    });
+  }
+  async getStats(init) {
+    return this.request("GET", `/v1/stats`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+  async getVersion(init) {
+    return this.request("GET", `/version`, {
+      body: undefined,
+      query: undefined,
+      init
+    });
+  }
+}
+// src/serve/openapi.ts
+function buildOpenApiDocument(version) {
+  const linkSchema = {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      domain_id: { type: "string" },
+      hostname: { type: "string" },
+      slug: { type: "string" },
+      destination_url: { type: "string" },
+      title: { type: "string", nullable: true },
+      active: { type: "boolean" },
+      expires_at: { type: "string", nullable: true },
+      short_url: { type: "string" },
+      metadata: { type: "object", additionalProperties: true },
+      created_at: { type: "string" },
+      updated_at: { type: "string" }
+    },
+    required: ["id", "domain_id", "hostname", "slug", "destination_url", "active", "created_at"]
+  };
+  const domainSchema = {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      hostname: { type: "string" },
+      provider: { type: "string" },
+      default_domain: { type: "boolean" },
+      origin_url: { type: "string", nullable: true },
+      notes: { type: "string", nullable: true },
+      metadata: { type: "object", additionalProperties: true },
+      created_at: { type: "string" },
+      updated_at: { type: "string" }
+    },
+    required: ["id", "hostname", "provider", "default_domain", "created_at"]
+  };
+  const linkStatsSchema = {
+    type: "object",
+    properties: {
+      link: { $ref: "#/components/schemas/Link" },
+      clicks: { type: "integer" },
+      last_clicked_at: { type: "string", nullable: true },
+      top_referrers: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { referer: { type: "string", nullable: true }, clicks: { type: "integer" } }
+        }
+      },
+      top_user_agents: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { user_agent: { type: "string", nullable: true }, clicks: { type: "integer" } }
+        }
+      }
+    },
+    required: ["link", "clicks"]
+  };
+  const probe = (extra = {}) => ({
+    type: "object",
+    properties: {
+      status: { type: "string" },
+      version: { type: "string" },
+      mode: { type: "string" },
+      ...extra
+    },
+    required: ["status", "version", "mode"]
+  });
+  return {
+    openapi: "3.0.3",
+    info: {
+      title: "ShortlinksApi",
+      version,
+      description: "Shortlink manager \u2014 custom domains, click tracking, and shortlink CRUD with API-key auth. PURE REMOTE (Amendment A1): reads/writes RDS Postgres directly."
+    },
+    servers: [{ url: "/" }],
+    components: {
+      securitySchemes: {
+        apiKey: { type: "apiKey", in: "header", name: "x-api-key" }
+      },
+      schemas: {
+        Link: linkSchema,
+        Domain: domainSchema,
+        LinkStats: linkStatsSchema,
+        LinkList: { type: "array", items: linkSchema },
+        DomainList: { type: "array", items: domainSchema },
+        TotalStats: {
+          type: "object",
+          properties: {
+            domains: { type: "integer" },
+            links: { type: "integer" },
+            clicks: { type: "integer" }
+          },
+          required: ["domains", "links", "clicks"]
+        },
+        CreateLinkRequest: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "Destination URL (http/https)." },
+            domain: { type: "string", description: "Hostname; defaults to the default domain." },
+            slug: { type: "string", description: "Custom slug; generated when omitted." },
+            title: { type: "string" },
+            expires_at: { type: "string", description: "ISO date/time." },
+            length: { type: "integer", description: "Generated slug length." },
+            metadata: { type: "object", additionalProperties: true }
+          },
+          required: ["url"]
+        },
+        AddDomainRequest: {
+          type: "object",
+          properties: {
+            hostname: { type: "string" },
+            provider: { type: "string" },
+            default: { type: "boolean" },
+            origin_url: { type: "string" },
+            notes: { type: "string" },
+            metadata: { type: "object", additionalProperties: true }
+          },
+          required: ["hostname"]
+        },
+        DeleteResponse: {
+          type: "object",
+          properties: { deleted: { type: "boolean" }, slug: { type: "string" } },
+          required: ["deleted"]
+        },
+        HealthStatus: probe({ db_latency_ms: { type: "integer" } }),
+        ReadyStatus: probe({ pending_migrations: { type: "array", items: { type: "string" } } }),
+        VersionInfo: probe({ name: { type: "string" } }),
+        ErrorResponse: {
+          type: "object",
+          properties: { error: { type: "string" }, reason: { type: "string" } },
+          required: ["error"]
+        }
+      }
+    },
+    paths: {
+      "/health": {
+        get: {
+          operationId: "getHealth",
+          summary: "Liveness probe.",
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/HealthStatus" } } } }
+          }
+        }
+      },
+      "/ready": {
+        get: {
+          operationId: "getReady",
+          summary: "Readiness probe (DB reachable and schema migrated).",
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/ReadyStatus" } } } }
+          }
+        }
+      },
+      "/version": {
+        get: {
+          operationId: "getVersion",
+          summary: "Service version and mode.",
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/VersionInfo" } } } }
+          }
+        }
+      },
+      "/v1/stats": {
+        get: {
+          operationId: "getStats",
+          summary: "Total domains/links/clicks counts.",
+          security: [{ apiKey: [] }],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/TotalStats" } } } }
+          }
+        }
+      },
+      "/v1/domains": {
+        get: {
+          operationId: "listDomains",
+          summary: "List configured domains.",
+          security: [{ apiKey: [] }],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/DomainList" } } } }
+          }
+        },
+        post: {
+          operationId: "addDomain",
+          summary: "Add or update a domain.",
+          security: [{ apiKey: [] }],
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: "#/components/schemas/AddDomainRequest" } } }
+          },
+          responses: {
+            "201": { content: { "application/json": { schema: { $ref: "#/components/schemas/Domain" } } } }
+          }
+        }
+      },
+      "/v1/links": {
+        get: {
+          operationId: "listLinks",
+          summary: "List shortlinks.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "domain", in: "query", schema: { type: "string" } },
+            { name: "active", in: "query", schema: { type: "boolean" } },
+            { name: "limit", in: "query", schema: { type: "integer" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/LinkList" } } } }
+          }
+        },
+        post: {
+          operationId: "createLink",
+          summary: "Create a shortlink.",
+          security: [{ apiKey: [] }],
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: "#/components/schemas/CreateLinkRequest" } } }
+          },
+          responses: {
+            "201": { content: { "application/json": { schema: { $ref: "#/components/schemas/Link" } } } }
+          }
+        }
+      },
+      "/v1/links/{slug}": {
+        get: {
+          operationId: "getLink",
+          summary: "Get a shortlink by slug.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "slug", in: "path", required: true, schema: { type: "string" } },
+            { name: "domain", in: "query", schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/Link" } } } }
+          }
+        },
+        delete: {
+          operationId: "deleteLink",
+          summary: "Delete a shortlink.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "slug", in: "path", required: true, schema: { type: "string" } },
+            { name: "domain", in: "query", schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/DeleteResponse" } } } }
+          }
+        }
+      },
+      "/v1/links/{slug}/enable": {
+        post: {
+          operationId: "enableLink",
+          summary: "Enable a shortlink.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "slug", in: "path", required: true, schema: { type: "string" } },
+            { name: "domain", in: "query", schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/Link" } } } }
+          }
+        }
+      },
+      "/v1/links/{slug}/disable": {
+        post: {
+          operationId: "disableLink",
+          summary: "Disable a shortlink.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "slug", in: "path", required: true, schema: { type: "string" } },
+            { name: "domain", in: "query", schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/Link" } } } }
+          }
+        }
+      },
+      "/v1/links/{slug}/stats": {
+        get: {
+          operationId: "getLinkStats",
+          summary: "Click stats for a shortlink.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "slug", in: "path", required: true, schema: { type: "string" } },
+            { name: "domain", in: "query", schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/LinkStats" } } } }
+          }
+        }
+      },
+      "/v1/resolve/{slug}": {
+        get: {
+          operationId: "resolveLink",
+          summary: "Resolve a slug to its destination without recording a click.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "slug", in: "path", required: true, schema: { type: "string" } },
+            { name: "domain", in: "query", schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/Link" } } } }
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  buildOpenApiDocument,
+  ShortlinksApiClient,
+  ApiError
+};

package/dist/serve/app.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shortlinks serve HTTP app.
+ *
+ * Surfaces the standard health/ready/version probes plus a versioned `/v1`
+ * REST API guarded by @hasna/contracts API-key auth. PURE REMOTE (Amendment
+ * A1): all reads/writes go through the injected Postgres store over the shared
+ * RDS — there is no sync engine or cache in the service.
+ */
+import { Hono } from "hono";
+import type { PoolQueryClient } from "../generated/storage-kit/query.js";
+import { PgShortlinksStore } from "../pg-store.js";
+export interface ServeAppDeps {
+    client: PoolQueryClient;
+    store: PgShortlinksStore;
+    version: string;
+    mode: string;
+    signingSecret: string;
+    isRevoked?: (kid: string) => boolean | Promise<boolean>;
+    audit?: (event: unknown) => void;
+}
+export declare function createServeApp(deps: ServeAppDeps): Hono;

package/dist/serve/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+/**
+ * `shortlinks-serve` — the cloud HTTP service entrypoint.
+ *
+ * PURE REMOTE (Amendment A1): reads/writes the shared RDS Postgres directly via
+ * the vendored storage kit. No sync engine, cache, or local database in the
+ * service.
+ *
+ * Usage:
+ *   shortlinks-serve            Run migrations (idempotent) then serve.
+ *   shortlinks-serve migrate    Run migrations and exit (one-shot task).
+ *   shortlinks-serve --no-migrate  Serve without running migrations on boot.
+ */
+export {};