@shipeasy/openapi 1.0.0 → 1.1.0

package/dist/resources/alert-rules.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { alertRuleCreateSchema, alertRuleUpdateSchema } from '../schemas/alert-rules.js';
+import { Transport } from '../transport.js';
+
+type AlertRuleCreateInput = z.input<typeof alertRuleCreateSchema>;
+type AlertRuleUpdateInput = z.input<typeof alertRuleUpdateSchema>;
+/**
+ * One metric-threshold alert rule. The cron evaluates `agg(metric)` over the
+ * trailing `windowHours` and raises an alert at `severity` when the value
+ * `comparator` `threshold` holds.
+ *
+ * `metricId` is fixed at create time — there is no update path for it (the
+ * metric also pins the aggregation). Tune `threshold`/`comparator`/
+ * `windowHours`/`severity`/`name`/`enabled` instead, or delete + recreate to
+ * repoint the rule at a different metric.
+ */
+interface AlertRule {
+    id: string;
+    name: string;
+    metricId: string;
+    metricName: string | null;
+    comparator: "gt" | "gte" | "lt" | "lte";
+    threshold: number;
+    windowHours: number;
+    severity: "danger" | "warn" | "info";
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AlertRulesClient {
+    /** All alert rules for the bound project (the list endpoint is not paginated). */
+    list(): Promise<AlertRule[]>;
+    /** Resolve a rule by exact id, unique id-prefix, or exact (unique) name. */
+    resolve(idOrName: string): Promise<AlertRule>;
+    create(input: AlertRuleCreateInput): Promise<{
+        id: string;
+    }>;
+    /** Patch tunable knobs. `metricId` is rejected by the schema (immutable). */
+    update(id: string, input: AlertRuleUpdateInput): Promise<{
+        id: string;
+    }>;
+    delete(id: string): Promise<{
+        ok: true;
+    }>;
+}
+declare function alertRulesClient(t: Transport): AlertRulesClient;
+
+export { type AlertRule, type AlertRuleCreateInput, type AlertRuleUpdateInput, type AlertRulesClient, alertRulesClient };

package/dist/resources/alert-rules.js

@@ -0,0 +1,66 @@
+// src/schemas/alert-rules.ts
+import { z } from "zod";
+var ALERT_COMPARATORS = ["gt", "gte", "lt", "lte"];
+var ALERT_SEVERITIES = ["danger", "warn", "info"];
+var alertRuleCreateSchema = z.object({
+  name: z.string().min(1).max(120).describe("Human label for the rule, shown on the alert and the rules list."),
+  metricId: z.string().min(1).describe("Id of the metric to evaluate."),
+  comparator: z.enum(ALERT_COMPARATORS).describe("How the metric value is compared to the threshold (gt/gte/lt/lte)."),
+  threshold: z.number().finite().describe("Threshold the metric value is compared against."),
+  windowHours: z.number().int().min(1).max(720).default(24).describe("Lookback window (hours) the metric is aggregated over. 1\u2013720."),
+  severity: z.enum(ALERT_SEVERITIES).default("warn").describe("Severity of the raised alert."),
+  enabled: z.boolean().default(true).describe("Whether the rule is evaluated by the cron.")
+}).strict();
+var alertRuleUpdateSchema = z.object({
+  name: z.string().min(1).max(120),
+  comparator: z.enum(ALERT_COMPARATORS),
+  threshold: z.number().finite(),
+  windowHours: z.number().int().min(1).max(720),
+  severity: z.enum(ALERT_SEVERITIES),
+  enabled: z.boolean()
+}).partial().strict();
+
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/resources/alert-rules.ts
+var BASE = "/api/admin/alert-rules";
+function alertRulesClient(t) {
+  async function list() {
+    return t.request("GET", BASE);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((r) => r.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((r) => r.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1)
+      throw new ApiError(`Alert rule id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((r) => r.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(
+        `Alert rule name '${idOrName}' is ambiguous \u2014 pass an id instead`,
+        400
+      );
+    throw new ApiError(`Alert rule '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    create: (input) => t.request("POST", BASE, alertRuleCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE}/${id}`, alertRuleUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE}/${id}`)
+  };
+}
+export {
+  alertRulesClient
+};

package/dist/resources/configs.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { configCreateSchema, configUpdateSchema, configDraftUpsertSchema, configPublishSchema } from '@shipeasy/core/schemas/configs';
-import { PageQuery, Page } from '@shipeasy/core/pagination';
+import { configCreateSchema, configUpdateSchema, configDraftUpsertSchema, configPublishSchema } from '../schemas/configs.js';
+import { PageQuery, Page } from '../schemas/pagination.js';
 import { Transport } from '../transport.js';
 
 /** Use input types so callers can omit fields the server defaults. */
@@ -57,6 +57,7 @@ declare const configsResource: {
         readonly create: z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnknown, z.ZodRecord<z.ZodEnum<{
                 dev: "dev";
@@ -67,6 +68,7 @@ declare const configsResource: {
         readonly update: z.ZodObject<{
             schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             value: z.ZodOptional<z.ZodUnknown>;
+            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strip>;
         readonly saveDraft: z.ZodObject<{
             env: z.ZodEnum<{
@@ -319,6 +321,7 @@ declare const configsResource: {
         readonly request: z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnknown, z.ZodRecord<z.ZodEnum<{
                 dev: "dev";
@@ -432,6 +435,7 @@ declare const configsResource: {
         readonly request: z.ZodObject<{
             schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             value: z.ZodOptional<z.ZodUnknown>;
+            folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strip>;
         readonly response: z.ZodObject<{
             id: z.ZodString;