@hasna/shortlinks 0.2.0 → 0.2.2

package/README.md

@@ -114,6 +114,12 @@ shortlinks domain add go.example.com --provider cloudflare
 
 Generated links use the default domain unless `--domain` is passed.
 
+Remove a domain (this also deletes all of its links and clicks):
+
+```bash
+shortlinks domain remove go.example.com
+```
+
 ## Cloudflare
 
 Create a dry-run plan:

package/dist/cli/index.js

@@ -2465,6 +2465,17 @@ class ShortlinksStore {
     `).get(normalized, hostnameOrId);
     return row ? domainFromRow(row) : null;
   }
+  deleteDomain(hostnameOrId) {
+    const domain = this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    this.database.db.query("DELETE FROM domains WHERE id = ?").run(domain.id);
+    const config = loadConfig();
+    if (config.defaultDomain && normalizeHostname(config.defaultDomain) === domain.hostname) {
+      updateConfig({ defaultDomain: undefined, publicBaseUrl: undefined });
+    }
+    return domain;
+  }
   getDefaultDomain() {
     const config = loadConfig();
     if (config.defaultDomain) {
@@ -2883,7 +2894,7 @@ async function upsertCloudflareDnsRecord(options) {
   return { id: created.id, action: "created" };
 }
 
-// node_modules/@hasna/events/dist/commander.js
+// node_modules/.pnpm/@hasna+events@0.1.13/node_modules/@hasna/events/dist/commander.js
 import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -2900,29 +2911,83 @@ function getPathValue(input, path) {
     return;
   }, input);
 }
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
+function getFieldValues(input, path) {
+  const values = [];
+  const push = (value) => {
+    if (!values.some((item) => Object.is(item, value)))
+      values.push(value);
+  };
+  if (path.includes(".") && path in input)
+    push(input[path]);
+  const nestedValue = getPathValue(input, path);
+  if (nestedValue !== undefined || !path.includes("."))
+    push(nestedValue);
+  return values;
+}
+function wildcardToRegExp(pattern, options = {}) {
+  let body = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        body += ".*";
+        index += 1;
+      } else {
+        body += options.segmentSafe ? "[^/]*" : ".*";
+      }
+    } else {
+      body += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${body}$`);
 }
-function matchString(value, matcher) {
+function matchString(value, matcher, options = {}) {
   if (matcher === undefined)
     return true;
   if (value === undefined)
     return false;
   const matchers = Array.isArray(matcher) ? matcher : [matcher];
-  return matchers.some((item) => wildcardToRegExp(item).test(value));
+  return matchers.some((item) => wildcardToRegExp(item, options).test(value));
 }
 function matchRecord(input, matcher) {
   if (!matcher)
     return true;
   return Object.entries(matcher).every(([path, expected]) => {
-    const actual = getPathValue(input, path);
-    if (typeof expected === "string" || Array.isArray(expected)) {
-      return matchString(actual === undefined ? undefined : String(actual), expected);
-    }
-    return actual === expected;
+    const actualValues = getFieldValues(input, path);
+    return matchField(actualValues, expected, path);
   });
 }
+function matchField(actualValues, expected, path) {
+  if (isNegativeMatcher(expected)) {
+    return !actualValues.some((actual) => matchPositiveField(actual, expected.not, path));
+  }
+  return actualValues.some((actual) => matchPositiveField(actual, expected, path));
+}
+function matchPositiveField(actual, expected, path) {
+  if (typeof expected === "string" || Array.isArray(expected)) {
+    return stringCandidates(actual).some((candidate) => matchString(candidate, expected, {
+      segmentSafe: path.endsWith("_path") || path.endsWith(".path")
+    }));
+  }
+  if (Array.isArray(actual)) {
+    return actual.some((item) => item === expected);
+  }
+  return actual === expected;
+}
+function stringCandidates(actual) {
+  if (actual === undefined)
+    return [];
+  if (Array.isArray(actual)) {
+    return actual.flatMap((item) => isPrimitiveFieldValue(item) ? [String(item)] : []);
+  }
+  return [String(actual)];
+}
+function isPrimitiveFieldValue(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isNegativeMatcher(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && "not" in value);
+}
 function eventMatchesFilter(event, filter) {
   return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
 }
@@ -2938,6 +3003,13 @@ var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
 function getEventsDataDir(override) {
   return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join4(homedir2(), ".hasna", "events");
 }
+function getActiveEventsDirEnv() {
+  if (process.env[HASNA_EVENTS_DIR_ENV])
+    return HASNA_EVENTS_DIR_ENV;
+  if (process.env[HASNA_EVENTS_HOME_ENV])
+    return HASNA_EVENTS_HOME_ENV;
+  return null;
+}
 
 class JsonEventsStore {
   dataDir;
@@ -3050,6 +3122,52 @@ class JsonEventsStore {
     });
   }
 }
+async function getEventsStatus(dataDir) {
+  const store = new JsonEventsStore(dataDir);
+  await store.init();
+  const [channels, events, deliveries] = await Promise.all([
+    store.listChannels(),
+    store.listEvents(),
+    store.listDeliveries()
+  ]);
+  const transports = channels.reduce((counts, channel) => {
+    counts[channel.transport] = (counts[channel.transport] ?? 0) + 1;
+    return counts;
+  }, {});
+  return {
+    service: "events",
+    schemaVersion: "1.0",
+    dataDir: store.dataDir,
+    env: {
+      primary: HASNA_EVENTS_DIR_ENV,
+      fallback: HASNA_EVENTS_HOME_ENV,
+      active: getActiveEventsDirEnv()
+    },
+    files: {
+      channels: statusFile(store.dataDir, "channels.json", channels.length),
+      events: statusFile(store.dataDir, "events.json", events.length),
+      deliveries: statusFile(store.dataDir, "deliveries.json", deliveries.length)
+    },
+    counts: {
+      channels: channels.length,
+      enabledChannels: channels.filter((channel) => channel.enabled).length,
+      disabledChannels: channels.filter((channel) => !channel.enabled).length,
+      events: events.length,
+      deliveries: deliveries.length
+    },
+    transports,
+    safety: {
+      includesEventPayloads: false,
+      includesWebhookSecrets: false,
+      listOutputsRedactSecrets: true,
+      statusOutputIsMetadataOnly: true
+    }
+  };
+}
+function statusFile(dataDir, fileName, records) {
+  const path = join4(dataDir, fileName);
+  return { path, exists: existsSync3(path), records };
+}
 var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
 function buildSignatureBase(timestamp, body) {
   return `${timestamp}.${body}`;
@@ -3275,7 +3393,7 @@ class EventsClient {
     }
     return deliveries;
   }
-  async testChannel(id, input = {}) {
+  async matchChannel(id, input = {}) {
     const channel = await this.store.getChannel(id);
     if (!channel)
       throw new Error(`Channel not found: ${id}`);
@@ -3292,6 +3410,34 @@ class EventsClient {
       time: input.time,
       id: input.id
     });
+    const matched = channelMatchesEvent(channel, event);
+    return {
+      channelId: channel.id,
+      matched,
+      event,
+      filters: channel.filters,
+      reason: matched ? undefined : channel.enabled ? "event did not match channel filters" : "channel is disabled"
+    };
+  }
+  async testChannel(id, input = {}, options = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const match = await this.matchChannel(id, input);
+    const event = match.event;
+    if (options.honorFilters && !match.matched) {
+      const timestamp = new Date().toISOString();
+      const result2 = createDeliveryResult(event, channel, [{
+        attempt: 1,
+        status: "skipped",
+        startedAt: timestamp,
+        completedAt: timestamp,
+        error: match.reason
+      }]);
+      result2.metadata = { reason: "filter_mismatch" };
+      await this.store.appendDelivery(result2);
+      return result2;
+    }
     const eventForChannel = await this.applyRedaction(event, channel);
     const result = await this.deliverWithRetry(eventForChannel, channel);
     await this.store.appendDelivery(result);
@@ -3402,6 +3548,76 @@ function normalizeRetryPolicy(policy) {
     multiplier: Math.max(1, policy?.multiplier ?? 2)
   };
 }
+function parseFieldMatchers(values, label, typed = false) {
+  if (!values?.length)
+    return;
+  const result = {};
+  for (const value of values) {
+    const parsed = parseMatcherExpression(value, label);
+    const path = parsed.path;
+    if (path in result)
+      throw new Error(`Duplicate ${label} filter path: ${path}`);
+    const matcherValue = typed ? parseTypedMatcherValue(parsed.rawValue, label) : parsed.rawValue;
+    result[path] = parsed.negated ? { not: matcherValue } : matcherValue;
+  }
+  return result;
+}
+function parseFilterOptions(options) {
+  const filter2 = {};
+  if (options.source)
+    filter2.source = options.source;
+  if (options.type)
+    filter2.type = options.type;
+  if (options.subject)
+    filter2.subject = options.subject;
+  if (options.severity)
+    filter2.severity = options.severity;
+  const data = mergeMatchers(parseFieldMatchers(options.data, "data"), parseFieldMatchers(options.dataJson, "data-json", true));
+  const metadata = mergeMatchers(parseFieldMatchers(options.metadata, "metadata"), parseFieldMatchers(options.metadataJson, "metadata-json", true));
+  if (Object.keys(data).length > 0)
+    filter2.data = data;
+  if (Object.keys(metadata).length > 0)
+    filter2.metadata = metadata;
+  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
+}
+function mergeMatchers(...records) {
+  const result = {};
+  for (const record of records) {
+    if (!record)
+      continue;
+    for (const [path, value] of Object.entries(record)) {
+      if (path in result)
+        throw new Error(`Duplicate filter path: ${path}`);
+      result[path] = value;
+    }
+  }
+  return result;
+}
+function parseTypedMatcherValue(value, label) {
+  const parsed = JSON.parse(value);
+  if (parsed === null || typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean" || Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+    return parsed;
+  }
+  throw new Error(`${label} filter JSON values must be string, string[], number, boolean, or null`);
+}
+function parseMatcherExpression(value, label) {
+  const negativeSeparator = value.indexOf("!=");
+  if (negativeSeparator > 0) {
+    return {
+      path: value.slice(0, negativeSeparator),
+      rawValue: value.slice(negativeSeparator + 2),
+      negated: true
+    };
+  }
+  const separator = value.indexOf("=");
+  if (separator <= 0)
+    throw new Error(`Invalid ${label} filter, expected path=value or path!=value: ${value}`);
+  return {
+    path: value.slice(0, separator),
+    rawValue: value.slice(separator + 1),
+    negated: false
+  };
+}
 function parseJsonObject2(value, fallback) {
   if (!value)
     return fallback;
@@ -3423,18 +3639,6 @@ function parseHeaders(values) {
   }
   return headers;
 }
-function parseFilter(options) {
-  const filter2 = {};
-  if (options.source)
-    filter2.source = options.source;
-  if (options.type)
-    filter2.type = options.type;
-  if (options.subject)
-    filter2.subject = options.subject;
-  if (options.severity)
-    filter2.severity = options.severity;
-  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
-}
 function createClient(options) {
   if (options.createClient)
     return options.createClient();
@@ -3452,16 +3656,16 @@ function hasJsonOption(options) {
 function wantsJson(actionOptions, command) {
   return hasJsonOption(actionOptions) || hasJsonOption(command);
 }
-function registerWebhookCommands(program, options) {
-  const webhooks = program.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
-  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
+function registerChannelCommands(program, options) {
+  const channels = program.command(options.channelsCommandName ?? "channels").description("Manage Hasna event channels");
+  channels.command("add").description("Add or replace a channel").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--data <path=value...>", "Event data field filter; string values, path!=value negatives, array-member matching, dot paths, * segment wildcard, ** recursive wildcard", collectValues, []).option("--metadata <path=value...>", "Event metadata field filter; string values, path!=value negatives, array-member matching, dot paths, * segment wildcard, ** recursive wildcard", collectValues, []).option("--data-json <path=json...>", "Event data field filter with typed JSON value; path!=json negatives supported", collectValues, []).option("--metadata-json <path=json...>", "Event metadata field filter with typed JSON value; path!=json negatives supported", collectValues, []).option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
     const timestamp = new Date().toISOString();
     const channel = {
       id: actionOptions.id,
       name: actionOptions.name,
       enabled: !actionOptions.disabled,
       transport: actionOptions.transport,
-      filters: parseFilter(actionOptions),
+      filters: parseFilterOptions(actionOptions),
       retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
       redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
       createdAt: timestamp,
@@ -3477,35 +3681,51 @@ function registerWebhookCommands(program, options) {
     const saved = await createClient(options).addChannel(channel);
     print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
   });
-  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    const channels = await createClient(options).listChannels();
+  channels.command("list").description("List configured channels").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const channels2 = await createClient(options).listChannels();
     if (wantsJson(actionOptions, command)) {
-      console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
+      console.log(JSON.stringify(sanitizeChannelsForOutput(channels2), null, 2));
       return;
     }
-    if (!channels.length) {
+    if (!channels2.length) {
       console.log("No channels configured.");
       return;
     }
-    for (const channel of channels) {
+    for (const channel of channels2) {
       console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
     }
   });
-  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+  channels.command("status").description("Show events channel storage status").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const status = await getEventsStatus(options.dataDir);
+    print(status, wantsJson(actionOptions, command), `events dataDir: ${status.dataDir}`);
+  });
+  channels.command("remove").description("Remove a channel").argument("<id>", "Channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
     const removed = await createClient(options).removeChannel(id);
     print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
   });
-  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+  channels.command("test").description("Send a test event to one channel").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--honor-filters", "Skip delivery when the sample event does not match channel filters", false).option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
     const result = await createClient(options).testChannel(id, {
-      source: options.source,
+      source: actionOptions.source ?? options.source,
       type: actionOptions.type,
       subject: actionOptions.subject ?? id,
       message: actionOptions.message,
-      data: parseJsonObject2(actionOptions.data, { test: true })
-    });
+      data: parseJsonObject2(actionOptions.data, { test: true }),
+      metadata: parseJsonObject2(actionOptions.metadata, {})
+    }, { honorFilters: actionOptions.honorFilters });
     print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
   });
-  return webhooks;
+  channels.command("match").description("Check whether a sample event matches one channel without delivering").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events match preview").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const result = await createClient(options).matchChannel(id, {
+      source: actionOptions.source ?? options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject2(actionOptions.data, { test: true }),
+      metadata: parseJsonObject2(actionOptions.metadata, {})
+    });
+    print(result, wantsJson(actionOptions, command), `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
+  });
+  return channels;
 }
 function registerEventCommands(program, options) {
   const events = program.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
@@ -3553,7 +3773,7 @@ function registerEventCommands(program, options) {
   return events;
 }
 function registerEventsCommands(program, options) {
-  registerWebhookCommands(program, options);
+  registerChannelCommands(program, options);
   registerEventCommands(program, options);
 }
 function parseNumber(value) {
@@ -4078,7 +4298,7 @@ import { dirname as dirname3, join as join6 } from "path";
 import { fileURLToPath } from "url";
 import { spawnSync as spawnSync3 } from "child_process";
 
-// ../open-contracts/dist/client/storage.js
+// node_modules/.pnpm/@hasna+contracts@0.5.2/node_modules/@hasna/contracts/dist/client/storage.js
 var __defProp2 = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -10537,6 +10757,13 @@ class CloudShortlinksStore {
     const domains = await this.listDomains();
     return domains.find((d) => d.default_domain) ?? domains[0] ?? null;
   }
+  async deleteDomain(hostnameOrId) {
+    const domain = await this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    await this.transport.del(`/domains/${enc(domain.hostname)}`);
+    return domain;
+  }
   async createLink(input) {
     return this.client.create("links", {
       url: input.destinationUrl,
@@ -10588,7 +10815,7 @@ class CloudShortlinksStore {
     const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
     if (!link)
       throw new Error("Link not found.");
-    await this.client.delete("links", link.slug, maybeSlug ? { query: { domain: domainOrSlug } } : {});
+    await this.transport.del(`/links/${enc(link.slug)}`, undefined, maybeSlug ? { query: { domain: domainOrSlug } } : {});
     return link;
   }
   async recordClick(_link, _input = {}) {
@@ -10628,6 +10855,9 @@ class LocalStore {
   async getDefaultDomain() {
     return this.inner.getDefaultDomain();
   }
+  async deleteDomain(hostnameOrId) {
+    return this.inner.deleteDomain(hostnameOrId);
+  }
   async createLink(input) {
     return this.inner.createLink(input);
   }
@@ -10913,6 +11143,17 @@ domainCmd.command("get <hostname>").description("Show a configured domain").opti
     handleError(error);
   }
 });
+domainCmd.command("remove <hostname>").alias("delete").alias("rm").description("Delete a domain and all of its links and clicks").option("-j, --json", "Output JSON").action(async (hostname2, opts) => {
+  try {
+    const domain = await withRuntimeStore((store) => store.deleteDomain(hostname2));
+    print2({ deleted: true, hostname: domain.hostname }, opts, () => {
+      console.log(source_default.green(`Domain removed: ${domain.hostname}`));
+      console.log(source_default.dim("Its links and clicks were deleted."));
+    });
+  } catch (error) {
+    handleError(error);
+  }
+});
 domainCmd.command("setup <hostname>").description("Add a domain locally and optionally prepare Cloudflare DNS").option("--default", "Make this the default domain").option("--origin <url>", "Origin redirect server URL").option("--cloudflare", "Upsert Cloudflare CNAME record").option("--target <hostname>", "CNAME target for Cloudflare DNS").option("--zone-id <id>", "Cloudflare zone ID").option("--dry-run", "Show the Cloudflare plan without changing DNS").option("-j, --json", "Output JSON").action(async (hostname2, opts) => {
   try {
     const result = await withRuntimeStore(async (store) => {

package/dist/client-store.d.ts

@@ -17,6 +17,7 @@ export declare class LocalStore implements Store {
     listDomains(): Promise<Domain[]>;
     getDomain(hostnameOrId: string): Promise<Domain | null>;
     getDefaultDomain(): Promise<Domain | null>;
+    deleteDomain(hostnameOrId: string): Promise<Domain>;
     createLink(input: CreateLinkInput): Promise<Link>;
     listLinks(options?: ListLinksOptions): Promise<Link[]>;
     getLink(domainOrSlug: string, maybeSlug?: string): Promise<Link | null>;

package/dist/cloud-store.d.ts

@@ -26,6 +26,7 @@ export declare class CloudShortlinksStore implements Store {
     listDomains(): Promise<Domain[]>;
     getDomain(hostnameOrId: string): Promise<Domain | null>;
     getDefaultDomain(): Promise<Domain | null>;
+    deleteDomain(hostnameOrId: string): Promise<Domain>;
     createLink(input: CreateLinkInput): Promise<Link>;
     listLinks(options?: {
         domain?: string;

package/dist/index.js

@@ -430,6 +430,17 @@ class ShortlinksStore {
     `).get(normalized, hostnameOrId);
     return row ? domainFromRow(row) : null;
   }
+  deleteDomain(hostnameOrId) {
+    const domain = this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    this.database.db.query("DELETE FROM domains WHERE id = ?").run(domain.id);
+    const config = loadConfig();
+    if (config.defaultDomain && normalizeHostname(config.defaultDomain) === domain.hostname) {
+      updateConfig({ defaultDomain: undefined, publicBaseUrl: undefined });
+    }
+    return domain;
+  }
   getDefaultDomain() {
     const config = loadConfig();
     if (config.defaultDomain) {
@@ -1003,6 +1014,13 @@ class PgShortlinksStore {
     `);
     return row ? domainFromRow2(row) : null;
   }
+  async deleteDomain(hostnameOrId) {
+    const domain = await this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    await this.pg.run("DELETE FROM domains WHERE id = ?", domain.id);
+    return domain;
+  }
   async createLink(input) {
     const domain = input.domain ? await this.getDomain(input.domain) : await this.getDefaultDomain();
     if (!domain) {
@@ -1178,7 +1196,7 @@ class PgShortlinksStore {
     throw new Error("Could not generate an unused slug after 32 attempts.");
   }
 }
-// ../open-contracts/dist/client/storage.js
+// node_modules/.pnpm/@hasna+contracts@0.5.2/node_modules/@hasna/contracts/dist/client/storage.js
 var __defProp2 = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -7637,6 +7655,13 @@ class CloudShortlinksStore {
     const domains = await this.listDomains();
     return domains.find((d) => d.default_domain) ?? domains[0] ?? null;
   }
+  async deleteDomain(hostnameOrId) {
+    const domain = await this.getDomain(hostnameOrId);
+    if (!domain)
+      throw new Error("Domain not found.");
+    await this.transport.del(`/domains/${enc(domain.hostname)}`);
+    return domain;
+  }
   async createLink(input) {
     return this.client.create("links", {
       url: input.destinationUrl,
@@ -7688,7 +7713,7 @@ class CloudShortlinksStore {
     const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
     if (!link)
       throw new Error("Link not found.");
-    await this.client.delete("links", link.slug, maybeSlug ? { query: { domain: domainOrSlug } } : {});
+    await this.transport.del(`/links/${enc(link.slug)}`, undefined, maybeSlug ? { query: { domain: domainOrSlug } } : {});
     return link;
   }
   async recordClick(_link, _input = {}) {
@@ -7728,6 +7753,9 @@ class LocalStore {
   async getDefaultDomain() {
     return this.inner.getDefaultDomain();
   }
+  async deleteDomain(hostnameOrId) {
+    return this.inner.deleteDomain(hostnameOrId);
+  }
   async createLink(input) {
     return this.inner.createLink(input);
   }
@@ -7773,7 +7801,7 @@ async function withStore(fn, env = process.env, options = {}) {
     await store.close();
   }
 }
-// ../open-contracts/dist/auth/index.js
+// node_modules/.pnpm/@hasna+contracts@0.5.2/node_modules/@hasna/contracts/dist/auth/index.js
 import { createHash as createHash3, createHmac, randomBytes as randomBytes3, timingSafeEqual } from "crypto";
 var API_KEY_TOKEN_VERSION = 1;
 var API_KEY_NAMESPACE = "hasna";
@@ -9975,6 +10003,11 @@ function buildOpenApiDocument(version) {
           properties: { deleted: { type: "boolean" }, slug: { type: "string" } },
           required: ["deleted"]
         },
+        DomainDeleteResponse: {
+          type: "object",
+          properties: { deleted: { type: "boolean" }, hostname: { 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" } }),
@@ -10045,6 +10078,19 @@ function buildOpenApiDocument(version) {
           }
         }
       },
+      "/v1/domains/{hostname}": {
+        delete: {
+          operationId: "deleteDomain",
+          summary: "Delete a domain and all of its links and clicks.",
+          security: [{ apiKey: [] }],
+          parameters: [
+            { name: "hostname", in: "path", required: true, schema: { type: "string" } }
+          ],
+          responses: {
+            "200": { content: { "application/json": { schema: { $ref: "#/components/schemas/DomainDeleteResponse" } } } }
+          }
+        }
+      },
       "/v1/links": {
         get: {
           operationId: "listLinks",
@@ -10246,6 +10292,18 @@ function createServeApp(deps) {
       return handleError(c, error);
     }
   });
+  app.delete("/v1/domains/:hostname", async (c) => {
+    const denied = await requireScopes(c, [`${APP_SLUG}:write`]);
+    if (denied)
+      return denied;
+    const hostname2 = c.req.param("hostname");
+    try {
+      const domain = await store.deleteDomain(hostname2);
+      return c.json({ deleted: true, hostname: domain.hostname });
+    } catch (error) {
+      return handleError(c, error);
+    }
+  });
   app.get("/v1/links", async (c) => {
     const denied = await requireScopes(c, [`${APP_SLUG}:read`]);
     if (denied)