@hasna/shortlinks 0.2.7 → 0.2.10

package/dist/cli/projection.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Capability-bearing URL projection.
+ *
+ * Incident 716957 (todos b03cc058): a stored destination that is itself a
+ * signed capability URL (an S3 presigned read URL, GCS, or CloudFront signed
+ * URL) was emitted verbatim by the CLI into a probe file and reproduced in a
+ * session transcript, granting bearer read access until expiry. `secrets scan`
+ * does not cover this class, so consumer-side containment is the interim
+ * behaviour required by the capability-bearing-output doctrine.
+ *
+ * Output therefore projects such a URL to its plain unsigned reference — the
+ * scheme/host/path with every capability query parameter stripped. A consumer
+ * resolving the projected reference goes through the normal unsigned path and
+ * never receives a bearer credential from a transcript.
+ */
+import type { Link } from "../types.js";
+/** True when `url` is an http(s) URL whose query carries a signed-capability parameter. */
+export declare function hasCapabilityQuery(url: string): boolean;
+/**
+ * Project `url` to its plain unsigned reference: the same scheme/host/path
+ * with every capability query parameter stripped and non-capability parameters
+ * preserved. Non-capability or malformed values are returned unchanged.
+ */
+export declare function projectDestinationUrl(url: string): string;
+/** Project a Link record's destination_url (identity when already plain). */
+export declare function projectLink(link: Link): Link;
+/**
+ * Project a CLI payload for output: a Link, an array of Links, or a LinkStats
+ * record get their destination_url projected; every other payload passes
+ * through untouched (same object reference).
+ */
+export declare function projectForOutput(data: unknown): unknown;

package/dist/client-store.d.ts

@@ -1,8 +1,7 @@
 import { CloudShortlinksStore } from "./cloud-store.js";
-import type { Env } from "@hasna/contracts/mode";
-import type { ListLinksOptions, Store, TotalStats } from "./store-interface.js";
+import type { Env, ListLinksOptions, Store, TotalStats } from "./store-interface.js";
 import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
-/** The self_hosted/cloud HTTP transport. Same client code for both tiers. */
+/** The hosted-API HTTP transport. */
 export { CloudShortlinksStore as ApiStore } from "./cloud-store.js";
 export type { Store } from "./store-interface.js";
 /**
@@ -30,15 +29,16 @@ export declare class LocalStore implements Store {
     close(): Promise<void>;
 }
 export interface ResolveStoreOptions {
-    /** Explicit local SQLite path (CLI `--db`); ignored in cloud mode. */
+    /** Explicit local SQLite path (CLI `--db`); ignored when the hosted API is selected. */
     dbPath?: string;
-    /** Transport overrides for the cloud client (test injection: fetchImpl, ...). */
+    /** Transport overrides for the hosted-API client (test injection: fetchImpl, ...). */
     cloudOverrides?: Parameters<typeof CloudShortlinksStore.fromEnv>[1];
 }
 /**
  * Resolve the active {@link Store} for the current environment. Returns the
- * cloud {@link ApiStore} when the client flip is on, otherwise a
- * {@link LocalStore}. Throws when cloud was requested but is misconfigured.
+ * hosted-API {@link ApiStore} when the client env is fully configured,
+ * otherwise a {@link LocalStore}. Throws when the hosted client is partially
+ * configured.
  */
 export declare function resolveStore(env?: Env, options?: ResolveStoreOptions): Store;
 /**

package/dist/cloud-store.d.ts

@@ -1,6 +1,5 @@
 import { resolveStorageClient, type HasnaStorageClient } from "@hasna/contracts/client/storage";
-import type { Env } from "@hasna/contracts/mode";
-import type { Store } from "./store-interface.js";
+import type { Env, Store } from "./store-interface.js";
 import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
 /**
  * Cloud-backed shortlinks store. All methods hit `/v1` over HTTPS with the
@@ -9,16 +8,19 @@ import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link,
  */
 export declare class CloudShortlinksStore implements Store {
     private readonly client;
-    readonly kind: "cloud-http";
+    readonly kind: "http";
     readonly transport: HasnaStorageClient["transport"];
     private constructor();
     /** Base `<origin>/v1` URL this store targets (for status/diagnostics). */
     get baseUrl(): string;
     /**
-     * Resolve a cloud store from the environment. Returns the store when the
-     * client-flip resolves to `cloud-http` (self_hosted + API_URL + API_KEY), else
-     * null so the caller falls back to the local store. Throws only when cloud was
-     * explicitly requested but is misconfigured (never silent local drift).
+     * Resolve a hosted-API store from the environment. The contracts client
+     * seam (`resolveStorageClient`) decides: an explicit API URL + API key in
+     * the environment selects the hosted client, and the fleet app-config on
+     * disk is the fallback tier; otherwise the caller uses its local store.
+     * Throws when only one of URL/key is set in the environment tier — a
+     * partially configured hosted client must fail loudly, never silently
+     * drift to the local dataset.
      */
     static fromEnv(env?: Env, overrides?: Parameters<typeof resolveStorageClient>[2]): CloudShortlinksStore | null;
     close(): Promise<void>;

package/dist/generated/storage-kit/backend.d.ts

@@ -0,0 +1,19 @@
+export declare const SERVER_DATA_BACKENDS: readonly ["sqlite", "postgresql"];
+export type ServerDataBackend = (typeof SERVER_DATA_BACKENDS)[number];
+export type Env = Record<string, string | undefined>;
+/** Upper-snake env token for an app name, e.g. `todos` -> `TODOS`. */
+export declare function envToken(name: string): string;
+export interface ServerDataBackendEnvKeys {
+    databaseUrlKeys: string[];
+}
+export declare function serverDataBackendEnvKeys(name: string): ServerDataBackendEnvKeys;
+export declare function assertNoLegacyStorageMode(name: string, env?: Env): void;
+export interface ServerDataBackendResolution {
+    backend: ServerDataBackend;
+    source: string;
+    databaseUrlPresent: boolean;
+    databaseUrlSource: string | null;
+}
+export declare function resolveServerDataBackend(name: string, env?: Env): ServerDataBackendResolution;
+/** Resolve the database URL without logging it. Returns `null` when unset. */
+export declare function resolveDatabaseUrl(name: string, env?: Env): string | null;

package/dist/generated/storage-kit/index.d.ts

@@ -1,5 +1,5 @@
-export declare const KIT_VERSION = "0.4.2";
-export * from "./mode.js";
+export declare const KIT_VERSION = "0.11.1";
+export * from "./backend.js";
 export * from "./tls.js";
 export * from "./query.js";
 export * from "./pool.js";

package/dist/generated/storage-kit/own.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read `key` from `source` only when `source` OWNS it.
+ *
+ * Returns `undefined` for an inherited property and for a null/undefined or
+ * non-object source, so a guarded read is a drop-in for `source?.[key]` that
+ * cannot be answered by the prototype chain.
+ */
+export declare function ownProp<T>(source: unknown, key: string): T | undefined;
+/** `ownProp` narrowed to a string, so a polluted non-string cannot slip through. */
+export declare function ownString(source: unknown, key: string): string | undefined;

package/dist/generated/storage-kit/pool.d.ts

@@ -14,20 +14,21 @@ export interface CreatePgPoolOptions extends TlsResolveOptions {
 }
 /** Build a `pg.Pool` with fleet-standard TLS handling. */
 export declare function createPgPool(options: CreatePgPoolOptions): Pool;
-export interface CreateCloudPoolFromEnvOptions extends TlsResolveOptions {
+export interface CreateServerPoolFromEnvOptions extends TlsResolveOptions {
     max?: number;
     idleTimeoutMillis?: number;
     connectionTimeoutMillis?: number;
     applicationName?: string;
 }
-export interface CloudPoolFromEnv {
+export interface ServerPoolFromEnv {
     client: PoolQueryClient;
     connectionSource: string;
 }
 /**
- * Resolve mode + database URL from the environment and build a cloud pool.
+ * Resolve backend + database URL from the environment and build the server's
+ * PostgreSQL pool.
  *
- * Throws when the resolved mode is not `cloud` (PURE REMOTE has no Postgres in
- * `local` mode) or when the database URL is missing. Never logs the URL.
+ * Throws when no database URL selects the `postgresql` backend. Never logs the
+ * URL.
  */
-export declare function createCloudPoolFromEnv(appName: string, options?: CreateCloudPoolFromEnvOptions): CloudPoolFromEnv;
+export declare function createServerPoolFromEnv(appName: string, options?: CreateServerPoolFromEnvOptions): ServerPoolFromEnv;

package/dist/generated/storage-kit/tls.d.ts

@@ -2,6 +2,9 @@
 export type PgSslConfig = boolean | {
     rejectUnauthorized: boolean;
     ca?: string;
+    cert?: string;
+    key?: string;
+    passphrase?: string;
 };
 export interface TlsResolveOptions {
     /** Inline CA bundle (PEM). Wins over every other CA source. */
@@ -12,14 +15,38 @@ export interface TlsResolveOptions {
     env?: Record<string, string | undefined>;
 }
 export type SslMode = "disable" | "prefer" | "require" | "verify-ca" | "verify-full";
+/**
+ * Remove the TLS query parameters once this module has resolved them into an
+ * explicit `ssl` option. pg re-parses `connectionString` AFTER merging pool
+ * options and lets the parse win, so leaving `sslmode` (or `ssl`, `sslcert`,
+ * `sslkey`, `sslrootcert`, `sslnegotiation`) in the URL replaces the resolved
+ * SSL object with pg's own — discarding the CA bundle with it.
+ *
+ * Non-TLS parameters and any fragment are preserved exactly.
+ */
+export declare function connectionStringWithoutTlsParameters(connectionString: string): string;
+/**
+ * Preserve pg's transport negotiation choice outside the stripped URL, so
+ * `sslnegotiation=direct` survives as an explicit pool option instead of being
+ * silently dropped.
+ */
+export declare function sslNegotiationFromConnectionString(connectionString: string): "postgres" | "direct" | undefined;
 /**
  * Extract the effective `sslmode` from a Postgres connection string. Honors the
- * `sslmode` query param and the legacy `ssl=true` boolean. Returns `disable`
- * when TLS is not requested.
+ * `sslmode` query param, the legacy `ssl=true` boolean, and pg's rule that
+ * `sslnegotiation=direct` implies TLS when no explicit SSL setting is present.
+ * Returns `disable` when TLS is not requested.
  */
 export declare function sslModeFromConnectionString(connectionString: string): SslMode;
 /**
  * Resolve the `pg` ssl config for a connection string. See the module header
- * for the full mode table. Returns `undefined` when TLS should be off.
+ * for the full mode table.
+ *
+ * Returns `false` when TLS was explicitly switched off, and `undefined` when the
+ * DSN expressed no TLS policy at all — those are different answers, and pg
+ * treats them differently: only `undefined` lets `PGSSLMODE` decide.
+ *
+ * The caller MUST hand pg `connectionStringWithoutTlsParameters(connectionString)`
+ * rather than the original DSN, or pg discards everything resolved here.
  */
 export declare function resolveTlsConfig(connectionString: string, options?: TlsResolveOptions): PgSslConfig | undefined;