@hasna/shortlinks 0.1.22 → 0.1.24

package/dist/runtime.d.ts

@@ -0,0 +1,65 @@
+export type ShortlinksStoreMode = "local" | "postgres";
+export type ShortlinksRuntimeEnv = Record<string, string | undefined>;
+export interface ShortlinksPostgresConfig {
+    provider: "postgres";
+    url: string;
+    ssl: boolean;
+}
+export interface ShortlinksRuntimeConfig {
+    service: "shortlinks";
+    mode: ShortlinksStoreMode;
+    database?: ShortlinksPostgresConfig;
+}
+export declare const SHORTLINKS_RUNTIME_ENV: {
+    readonly store: "HASNA_SHORTLINKS_STORE";
+    readonly databaseUrl: "HASNA_SHORTLINKS_DATABASE_URL";
+    readonly databaseSsl: "HASNA_SHORTLINKS_DATABASE_SSL";
+};
+export declare const SHORTLINKS_RUNTIME_FALLBACK_ENV: {
+    readonly store: "SHORTLINKS_STORE";
+    readonly databaseUrl: "SHORTLINKS_DATABASE_URL";
+    readonly databaseSsl: "SHORTLINKS_DATABASE_SSL";
+};
+export declare const CANONICAL_SHORTLINKS_POSTGRES_CLUSTER = "hasna-xyz-infra-apps-prod-postgres";
+export declare const CANONICAL_SHORTLINKS_POSTGRES_DATABASE = "shortlinks";
+export declare const CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH = "hasna/xyz/opensource/shortlinks/prod/postgres";
+export interface CanonicalShortlinksPostgresConfig {
+    cluster: typeof CANONICAL_SHORTLINKS_POSTGRES_CLUSTER;
+    database: typeof CANONICAL_SHORTLINKS_POSTGRES_DATABASE;
+    runtimeSecretPath: typeof CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH;
+    primaryEnv: typeof SHORTLINKS_RUNTIME_ENV.databaseUrl;
+    fallbackEnv: typeof SHORTLINKS_RUNTIME_FALLBACK_ENV.databaseUrl;
+}
+export interface RuntimeEnvStatus {
+    name: string;
+    active_name: string;
+    configured: boolean;
+}
+export interface ShortlinksRuntimeStatus {
+    ok: boolean;
+    service: "shortlinks";
+    mode: ShortlinksStoreMode;
+    local_default: boolean;
+    postgres_enabled: boolean;
+    database: {
+        configured: boolean;
+        provider: "postgres" | null;
+        redacted_url: string | null;
+        ssl: boolean | null;
+    };
+    env: Record<keyof typeof SHORTLINKS_RUNTIME_ENV, RuntimeEnvStatus>;
+    canonical: CanonicalShortlinksPostgresConfig;
+    issues: string[];
+    warnings: string[];
+    no_network: true;
+}
+export declare function getCanonicalShortlinksPostgresConfig(): CanonicalShortlinksPostgresConfig;
+export declare function parseShortlinksStoreMode(value: string | undefined): ShortlinksStoreMode;
+export declare function getShortlinksStoreMode(env?: ShortlinksRuntimeEnv): ShortlinksStoreMode;
+export declare function getShortlinksDatabaseUrl(env?: ShortlinksRuntimeEnv): string | undefined;
+export declare function getShortlinksDatabaseSsl(env?: ShortlinksRuntimeEnv): boolean;
+export declare function getShortlinksRuntimeEnvName(env: ShortlinksRuntimeEnv, key: keyof typeof SHORTLINKS_RUNTIME_ENV): string;
+export declare function loadShortlinksRuntimeConfig(env?: ShortlinksRuntimeEnv): ShortlinksRuntimeConfig;
+export declare function assertShortlinksPostgresConfig(config: ShortlinksRuntimeConfig): void;
+export declare function getShortlinksRuntimeStatus(env?: ShortlinksRuntimeEnv): ShortlinksRuntimeStatus;
+export declare function redactDatabaseUrl(value: string | undefined): string | null;

package/dist/runtime.js

@@ -0,0 +1,214 @@
+// @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/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"
+};
+var CANONICAL_SHORTLINKS_POSTGRES_CLUSTER = "hasna-xyz-infra-apps-prod-postgres";
+var CANONICAL_SHORTLINKS_POSTGRES_DATABASE = "shortlinks";
+var CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH = "hasna/xyz/opensource/shortlinks/prod/postgres";
+function getCanonicalShortlinksPostgresConfig() {
+  return {
+    cluster: CANONICAL_SHORTLINKS_POSTGRES_CLUSTER,
+    database: CANONICAL_SHORTLINKS_POSTGRES_DATABASE,
+    runtimeSecretPath: CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH,
+    primaryEnv: SHORTLINKS_RUNTIME_ENV.databaseUrl,
+    fallbackEnv: SHORTLINKS_RUNTIME_FALLBACK_ENV.databaseUrl
+  };
+}
+function parseShortlinksStoreMode(value) {
+  const normalized = clean(value)?.toLowerCase();
+  if (!normalized)
+    return "local";
+  if (normalized === "local" || normalized === "postgres")
+    return normalized;
+  if (normalized === "pg")
+    return "postgres";
+  throw new Error(`${SHORTLINKS_RUNTIME_ENV.store} must be local or postgres`);
+}
+function getShortlinksStoreMode(env = process.env) {
+  return parseShortlinksStoreMode(readRuntimeEnv(env, "store").value);
+}
+function getShortlinksDatabaseUrl(env = process.env) {
+  return readRuntimeEnv(env, "databaseUrl").value;
+}
+function getShortlinksDatabaseSsl(env = process.env) {
+  return parseBoolean(readRuntimeEnv(env, "databaseSsl").value, true);
+}
+function getShortlinksRuntimeEnvName(env, key) {
+  const primary = SHORTLINKS_RUNTIME_ENV[key];
+  if (clean(env[primary]))
+    return primary;
+  return SHORTLINKS_RUNTIME_FALLBACK_ENV[key];
+}
+function loadShortlinksRuntimeConfig(env = process.env) {
+  const mode = getShortlinksStoreMode(env);
+  const databaseUrl = getShortlinksDatabaseUrl(env);
+  return {
+    service: "shortlinks",
+    mode,
+    ...databaseUrl ? {
+      database: {
+        provider: "postgres",
+        url: databaseUrl,
+        ssl: getShortlinksDatabaseSsl(env)
+      }
+    } : {}
+  };
+}
+function assertShortlinksPostgresConfig(config) {
+  if (config.mode !== "postgres")
+    return;
+  if (!config.database?.url) {
+    throw new Error(`${SHORTLINKS_RUNTIME_ENV.databaseUrl} is required when ${SHORTLINKS_RUNTIME_ENV.store}=postgres`);
+  }
+}
+function getShortlinksRuntimeStatus(env = process.env) {
+  const issues = [];
+  const warnings = [];
+  let config;
+  try {
+    config = loadShortlinksRuntimeConfig(env);
+  } catch (error) {
+    issues.push(error instanceof Error ? error.message : String(error));
+    config = { service: "shortlinks", mode: "local" };
+  }
+  try {
+    assertShortlinksPostgresConfig(config);
+  } catch (error) {
+    issues.push(error instanceof Error ? error.message : String(error));
+  }
+  if (config.mode === "local" && config.database?.url) {
+    warnings.push(`${SHORTLINKS_RUNTIME_ENV.store}=local ignores configured Postgres database settings`);
+  }
+  return {
+    ok: issues.length === 0,
+    service: "shortlinks",
+    mode: config.mode,
+    local_default: config.mode === "local",
+    postgres_enabled: config.mode === "postgres",
+    database: {
+      configured: Boolean(config.database?.url),
+      provider: config.database?.provider ?? null,
+      redacted_url: redactDatabaseUrl(config.database?.url),
+      ssl: config.database?.ssl ?? null
+    },
+    env: runtimeEnvStatus(env),
+    canonical: getCanonicalShortlinksPostgresConfig(),
+    issues,
+    warnings,
+    no_network: true
+  };
+}
+function redactDatabaseUrl(value) {
+  if (!value)
+    return null;
+  try {
+    const url = new URL(value);
+    if (url.username)
+      url.username = "***";
+    if (url.password)
+      url.password = "***";
+    for (const key of Array.from(url.searchParams.keys())) {
+      if (isSensitiveQueryKey(key))
+        url.searchParams.set(key, "***");
+    }
+    return url.toString();
+  } catch {
+    return "(redacted)";
+  }
+}
+function runtimeEnvStatus(env) {
+  return Object.fromEntries(Object.entries(SHORTLINKS_RUNTIME_ENV).map(([key, name]) => {
+    const activeName = getShortlinksRuntimeEnvName(env, key);
+    return [
+      key,
+      {
+        name,
+        active_name: activeName,
+        configured: Boolean(clean(env[activeName]))
+      }
+    ];
+  }));
+}
+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 isSensitiveQueryKey(key) {
+  return /(?:^|[_-])(pass(?:word)?|pwd|secret|token|credential|auth|api[_-]?key|access[_-]?key)(?:$|[_-])/i.test(key);
+}
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+export {
+  redactDatabaseUrl,
+  parseShortlinksStoreMode,
+  loadShortlinksRuntimeConfig,
+  getShortlinksStoreMode,
+  getShortlinksRuntimeStatus,
+  getShortlinksRuntimeEnvName,
+  getShortlinksDatabaseUrl,
+  getShortlinksDatabaseSsl,
+  getCanonicalShortlinksPostgresConfig,
+  assertShortlinksPostgresConfig,
+  SHORTLINKS_RUNTIME_FALLBACK_ENV,
+  SHORTLINKS_RUNTIME_ENV,
+  CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH,
+  CANONICAL_SHORTLINKS_POSTGRES_DATABASE,
+  CANONICAL_SHORTLINKS_POSTGRES_CLUSTER
+};

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";