nuxt-observe 0.0.2

package/dist/runtime/app/composables/useObserveErrors.js

@@ -0,0 +1,85 @@
+import { computed, ref, watch, onBeforeUnmount } from "vue";
+import { useFetch } from "#imports";
+import { useObservePeriod } from "./useObservePeriod.js";
+import { useObserveScope } from "./useObserveScope.js";
+const LIMIT = 50;
+export function useObserveErrors() {
+  const { period } = useObservePeriod();
+  const { serviceSlug, groupSlug } = useObserveScope();
+  const q = ref("");
+  const debouncedQ = ref("");
+  const sort = ref("recent");
+  const pageState = ref(1);
+  let timer;
+  watch(q, (v) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      debouncedQ.value = v.trim();
+    }, 300);
+  });
+  onBeforeUnmount(() => {
+    if (timer) clearTimeout(timer);
+  });
+  watch([debouncedQ, sort, period, serviceSlug, groupSlug], () => {
+    pageState.value = 1;
+  });
+  const page = computed({
+    get: () => pageState.value,
+    set: (p) => {
+      pageState.value = p;
+    }
+  });
+  const query = computed(() => ({
+    period: period.value,
+    ...serviceSlug.value ? { service: serviceSlug.value } : {},
+    ...groupSlug.value ? { group: groupSlug.value } : {},
+    ...debouncedQ.value ? { q: debouncedQ.value } : {},
+    sort: sort.value,
+    limit: LIMIT,
+    offset: (pageState.value - 1) * LIMIT
+  }));
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/errors",
+    { key: "observe:errors", query }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh,
+    q,
+    sort,
+    page,
+    limit: LIMIT
+  };
+}
+export function useObserveErrorGroup(fingerprint) {
+  const { period } = useObservePeriod();
+  const { serviceSlug, groupSlug } = useObserveScope();
+  const pageState = ref(1);
+  const page = computed({
+    get: () => pageState.value,
+    set: (p) => {
+      pageState.value = p;
+    }
+  });
+  const query = computed(() => ({
+    period: period.value,
+    ...serviceSlug.value ? { service: serviceSlug.value } : {},
+    ...groupSlug.value ? { group: groupSlug.value } : {},
+    limit: LIMIT,
+    offset: (pageState.value - 1) * LIMIT
+  }));
+  const { data, pending, error, refresh } = useFetch(
+    `/api/observe/errors/${fingerprint}`,
+    { key: `observe:error:${fingerprint}`, query }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh,
+    page,
+    limit: LIMIT
+  };
+}

package/dist/runtime/app/composables/useObserveGroups.d.ts

@@ -0,0 +1,27 @@
+import type { Ref } from 'vue';
+import type { GroupListItem, ServiceListItem } from '../../shared/schema/provisioning.js';
+export interface UseObserveGroupsReturn {
+    data: Ref<GroupListItem[] | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+    create: (name: string) => Promise<GroupListItem>;
+    update: (id: string, name: string) => Promise<GroupListItem>;
+    remove: (id: string) => Promise<{
+        ok: true;
+    }>;
+    setMembership: (id: string, serviceIds: string[]) => Promise<{
+        ok: true;
+    }>;
+}
+export declare function useObserveGroups(): UseObserveGroupsReturn;
+export interface UseObserveGroupDetailReturn {
+    data: Ref<{
+        group: GroupListItem;
+        services: ServiceListItem[];
+    } | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+}
+export declare function useObserveGroupDetail(id: string): UseObserveGroupDetailReturn;

package/dist/runtime/app/composables/useObserveGroups.js

@@ -0,0 +1,33 @@
+import { useFetch } from "#imports";
+export function useObserveGroups() {
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/groups",
+    { key: "observe:groups" }
+  );
+  const create = (name) => $fetch("/api/observe/groups", { method: "POST", body: { name } });
+  const update = (id, name) => $fetch(`/api/observe/groups/${id}`, { method: "PATCH", body: { name } });
+  const remove = (id) => $fetch(`/api/observe/groups/${id}`, { method: "DELETE" });
+  const setMembership = (id, serviceIds) => $fetch(`/api/observe/groups/${id}/services`, { method: "PUT", body: { serviceIds } });
+  return {
+    data,
+    pending,
+    error,
+    refresh,
+    create,
+    update,
+    remove,
+    setMembership
+  };
+}
+export function useObserveGroupDetail(id) {
+  const { data, pending, error, refresh } = useFetch(
+    `/api/observe/groups/${id}`,
+    { key: `observe:group:${id}` }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh
+  };
+}

package/dist/runtime/app/composables/useObserveJourney.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from 'vue';
+import { type JourneyMode, type JourneyResponse } from '../../shared/schema/journey.js';
+export interface UseObserveJourneyReturn {
+    data: Ref<JourneyResponse | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+}
+/**
+ * The one fetch behind the journey timeline. `mode`/`key` are reactive (URL-driven
+ * on the page). The selector param depends on the mode (trace -> ?traceId), so the
+ * query maps through MODE_PARAM. `immediate` is gated on an initial key so a bare
+ * /journey visit does not fire an empty-selector 400; a later search navigation
+ * populates the key and useFetch refetches on the reactive query change.
+ */
+export declare function useObserveJourney(mode: Ref<JourneyMode>, key: Ref<string>, opts?: {
+    limit?: number;
+    key?: string;
+}): UseObserveJourneyReturn;

package/dist/runtime/app/composables/useObserveJourney.js

@@ -0,0 +1,19 @@
+import { computed } from "vue";
+import { useFetch } from "#imports";
+import { MODE_PARAM } from "../../shared/schema/journey.js";
+export function useObserveJourney(mode, key, opts = {}) {
+  const query = computed(() => ({
+    [MODE_PARAM[mode.value]]: key.value,
+    ...opts.limit ? { limit: opts.limit } : {}
+  }));
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/journey",
+    { key: opts.key ?? "observe:journey", query, immediate: !!key.value }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh
+  };
+}

package/dist/runtime/app/composables/useObserveLogFacets.d.ts

@@ -0,0 +1,11 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { LogsFacetsResponse } from '../../shared/schema/logs-query.js';
+export interface UseObserveLogFacetsReturn {
+    data: Ref<LogsFacetsResponse | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+    versions: ComputedRef<string[]>;
+}
+/** Feeds the filter bar's version dropdown, narrowed by the navbar scope switcher. */
+export declare function useObserveLogFacets(): UseObserveLogFacetsReturn;

package/dist/runtime/app/composables/useObserveLogFacets.js

@@ -0,0 +1,21 @@
+import { computed } from "vue";
+import { useFetch } from "#imports";
+import { useObserveScope } from "./useObserveScope.js";
+export function useObserveLogFacets() {
+  const { serviceSlug, groupSlug } = useObserveScope();
+  const query = computed(() => ({
+    ...serviceSlug.value ? { service: serviceSlug.value } : {},
+    ...groupSlug.value ? { group: groupSlug.value } : {}
+  }));
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/facets",
+    { key: "observe:facets", query }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh,
+    versions: computed(() => data.value?.versions ?? [])
+  };
+}

package/dist/runtime/app/composables/useObserveLogs.d.ts

@@ -0,0 +1,28 @@
+import { type Ref, type WritableComputedRef } from 'vue';
+import type { LogListResponse } from '../../shared/schema/logs-query.js';
+export interface LogsFilters {
+    levels: number[];
+    versions: string[];
+    route: string | null;
+    feature: string | null;
+    q: string;
+    traceId: string | null;
+}
+export interface UseObserveLogsReturn {
+    data: Ref<LogListResponse | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+    filters: Ref<LogsFilters>;
+    setFilters: (patch: Partial<LogsFilters>) => void;
+    clearFilters: () => void;
+    page: WritableComputedRef<number>;
+    limit: number;
+}
+/**
+ * The logs explorer's filter state + list fetch. Filters initialise from the URL query
+ * so a shared link restores them; every mutation writes the query back via router.replace
+ * (spreading ...route.query, so the navbar's ?period= and the cookie scope coexist).
+ * Scope + period compose from the shared shell state exactly as useObserveStats does.
+ */
+export declare function useObserveLogs(): UseObserveLogsReturn;

package/dist/runtime/app/composables/useObserveLogs.js

@@ -0,0 +1,100 @@
+import { computed } from "vue";
+import { useFetch, useState, useRoute, useRouter } from "#imports";
+import { useObservePeriod } from "./useObservePeriod.js";
+import { useObserveScope } from "./useObserveScope.js";
+const LIMIT = 50;
+function firstStr(v) {
+  const s = Array.isArray(v) ? v[0] : v;
+  return typeof s === "string" ? s : void 0;
+}
+function csvNumbers(v) {
+  const s = firstStr(v);
+  if (!s) return [];
+  return s.split(",").map((x) => Number(x.trim())).filter((n) => Number.isInteger(n) && n >= 0 && n <= 5);
+}
+function csvStrings(v) {
+  const s = firstStr(v);
+  if (!s) return [];
+  return s.split(",").map((x) => x.trim()).filter((x) => x.length > 0);
+}
+export function useObserveLogs() {
+  const route = useRoute();
+  const router = useRouter();
+  const { period } = useObservePeriod();
+  const { serviceSlug, groupSlug } = useObserveScope();
+  const filters = useState("observe:logs-filters", () => ({
+    levels: csvNumbers(route.query.levels),
+    versions: csvStrings(route.query.versions),
+    route: firstStr(route.query.route) ?? null,
+    feature: firstStr(route.query.feature) ?? null,
+    q: firstStr(route.query.q) ?? "",
+    traceId: firstStr(route.query.traceId) ?? null
+  }));
+  const pageState = useState("observe:logs-page", () => {
+    const p = Number(firstStr(route.query.page));
+    return Number.isInteger(p) && p >= 1 ? p : 1;
+  });
+  function syncUrl() {
+    const q = { ...route.query };
+    delete q.levels;
+    delete q.versions;
+    delete q.route;
+    delete q.feature;
+    delete q.q;
+    delete q.traceId;
+    delete q.page;
+    if (filters.value.levels.length) q.levels = filters.value.levels.join(",");
+    if (filters.value.versions.length) q.versions = filters.value.versions.join(",");
+    if (filters.value.route) q.route = filters.value.route;
+    if (filters.value.feature) q.feature = filters.value.feature;
+    if (filters.value.q) q.q = filters.value.q;
+    if (filters.value.traceId) q.traceId = filters.value.traceId;
+    if (pageState.value > 1) q.page = String(pageState.value);
+    router.replace({ query: q });
+  }
+  const setFilters = (patch) => {
+    filters.value = { ...filters.value, ...patch };
+    pageState.value = 1;
+    syncUrl();
+  };
+  const clearFilters = () => {
+    filters.value = { levels: [], versions: [], route: null, feature: null, q: "", traceId: null };
+    pageState.value = 1;
+    syncUrl();
+  };
+  const page = computed({
+    get: () => pageState.value,
+    set: (p) => {
+      pageState.value = p;
+      syncUrl();
+    }
+  });
+  const query = computed(() => ({
+    period: period.value,
+    ...serviceSlug.value ? { service: serviceSlug.value } : {},
+    ...groupSlug.value ? { group: groupSlug.value } : {},
+    ...filters.value.levels.length ? { levels: filters.value.levels.join(",") } : {},
+    ...filters.value.versions.length ? { versions: filters.value.versions.join(",") } : {},
+    ...filters.value.route ? { route: filters.value.route } : {},
+    ...filters.value.feature ? { feature: filters.value.feature } : {},
+    ...filters.value.q ? { q: filters.value.q } : {},
+    ...filters.value.traceId ? { traceId: filters.value.traceId } : {},
+    limit: LIMIT,
+    offset: (pageState.value - 1) * LIMIT
+  }));
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/logs",
+    { key: "observe:logs", query }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh,
+    filters,
+    setFilters,
+    clearFilters,
+    page,
+    limit: LIMIT
+  };
+}

package/dist/runtime/app/composables/useObserveMigrations.d.ts

@@ -0,0 +1,17 @@
+import type { Ref } from 'vue';
+import type { MigrationStatusResponse, MigrationRunFrame } from '../../shared/schema/migrations.js';
+export interface UseObserveMigrationsReturn {
+    status: Ref<MigrationStatusResponse | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+    run: (ids: string[] | undefined, onFrame: (frame: MigrationRunFrame) => void) => Promise<void>;
+}
+/**
+ * The one composable behind the migration console. `status` is the admin status fetch;
+ * `run` POSTs to /run and reads the SSE-framed response body as a stream (fetch +
+ * TextDecoder, NOT the native EventSource — its auto-reconnect could re-trigger a run),
+ * splitting on the SSE frame boundary and parsing each `data:` line, invoking `onFrame`
+ * as each frame arrives so the page can append to its terminal buffer live.
+ */
+export declare function useObserveMigrations(): UseObserveMigrationsReturn;

package/dist/runtime/app/composables/useObserveMigrations.js

@@ -0,0 +1,49 @@
+import { useFetch } from "#imports";
+export function useObserveMigrations() {
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/migrations",
+    { key: "observe:migrations" }
+  );
+  async function run(ids, onFrame) {
+    const res = await fetch("/api/observe/migrations/run", {
+      method: "POST",
+      headers: { "content-type": "application/json", "accept": "text/event-stream" },
+      body: JSON.stringify(ids ? { ids } : {})
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Migration run failed to start (${res.status})`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const flushFrame = (raw) => {
+      const dataLine = raw.split("\n").find((l) => l.startsWith("data:"));
+      if (!dataLine) return;
+      const json = dataLine.slice("data:".length).trim();
+      if (!json) return;
+      try {
+        onFrame(JSON.parse(json));
+      } catch {
+        onFrame({ type: "log", line: json });
+      }
+    };
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep;
+      while ((sep = buffer.indexOf("\n\n")) !== -1) {
+        flushFrame(buffer.slice(0, sep));
+        buffer = buffer.slice(sep + 2);
+      }
+    }
+    if (buffer.trim()) flushFrame(buffer);
+  }
+  return {
+    status: data,
+    pending,
+    error,
+    refresh,
+    run
+  };
+}

package/dist/runtime/app/composables/useObserveOverview.d.ts

@@ -0,0 +1,14 @@
+import { type Ref } from 'vue';
+import type { OverviewResponse } from '../../shared/schema/overview.js';
+export interface UseObserveOverviewReturn {
+    data: Ref<OverviewResponse | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+}
+/**
+ * The one overview fetch. Keyed explicitly so the layout (switcher) and the page
+ * share a single request instead of each firing their own; the reactive query means
+ * changing the period or the selected observable refetches automatically.
+ */
+export declare function useObserveOverview(): UseObserveOverviewReturn;

package/dist/runtime/app/composables/useObserveOverview.js

@@ -0,0 +1,23 @@
+import { computed } from "vue";
+import { useFetch } from "#imports";
+import { useObservePeriod } from "./useObservePeriod.js";
+import { useObserveScope } from "./useObserveScope.js";
+export function useObserveOverview() {
+  const { period } = useObservePeriod();
+  const { serviceSlug, groupSlug } = useObserveScope();
+  const query = computed(() => ({
+    period: period.value,
+    ...serviceSlug.value ? { service: serviceSlug.value } : {},
+    ...groupSlug.value ? { group: groupSlug.value } : {}
+  }));
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/overview",
+    { key: "observe:overview", query }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh
+  };
+}

package/dist/runtime/app/composables/useObservePeriod.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+import { type Period } from '../../shared/utils/period.js';
+/**
+ * Selected dashboard time window, shared across the shell and every page. Initialised
+ * from ?period= so a shared link restores the window; set() writes the query back with
+ * router.replace so the URL always reflects the current selection.
+ */
+export declare function useObservePeriod(): {
+    period: Ref<Period>;
+    setPeriod: (p: Period) => void;
+};

package/dist/runtime/app/composables/useObservePeriod.js

@@ -0,0 +1,18 @@
+import { useState, useRoute, useRouter } from "#imports";
+import { PERIODS } from "../../shared/utils/period.js";
+function isPeriod(value) {
+  return typeof value === "string" && PERIODS.includes(value);
+}
+export function useObservePeriod() {
+  const route = useRoute();
+  const router = useRouter();
+  const period = useState(
+    "observe:period",
+    () => isPeriod(route.query.period) ? route.query.period : "24h"
+  );
+  const setPeriod = (p) => {
+    period.value = p;
+    router.replace({ query: { ...route.query, period: p } });
+  };
+  return { period, setPeriod };
+}

package/dist/runtime/app/composables/useObserveRollout.d.ts

@@ -0,0 +1,20 @@
+import { type Ref } from 'vue';
+import type { VersionStat, VersionCompare, RegressionResponse } from '../../shared/schema/rollout.js';
+export interface UseObserveRolloutReturn {
+    versions: Ref<VersionStat[] | null | undefined>;
+    compare: Ref<VersionCompare | null | undefined>;
+    regressions: Ref<RegressionResponse | null | undefined>;
+    /** true = a single service is selected, so the regressions panel is meaningful */
+    hasService: Ref<boolean>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+}
+/**
+ * The rollout page's three reads behind one composable. versions + compare follow any
+ * selector (service, group, or full scope) with the standard reactive-query auto-refetch.
+ * regressions is per-service only (version_tracking is a service flag), so it is driven
+ * manually and only fires when a service slug is selected - a group/all-scope view would
+ * 400, so we skip it rather than surface a spurious error.
+ */
+export declare function useObserveRollout(): UseObserveRolloutReturn;

package/dist/runtime/app/composables/useObserveRollout.js

@@ -0,0 +1,55 @@
+import { computed, watch } from "vue";
+import { useFetch } from "#imports";
+import { useObservePeriod } from "./useObservePeriod.js";
+import { useObserveScope } from "./useObserveScope.js";
+export function useObserveRollout() {
+  const { period } = useObservePeriod();
+  const { serviceSlug, groupSlug } = useObserveScope();
+  const hasService = computed(() => !!serviceSlug.value);
+  const query = computed(() => ({
+    period: period.value,
+    ...serviceSlug.value ? { service: serviceSlug.value } : {},
+    ...groupSlug.value ? { group: groupSlug.value } : {}
+  }));
+  const versionsFetch = useFetch(
+    "/api/observe/rollout/versions",
+    { key: "observe:rollout:versions", query }
+  );
+  const compareFetch = useFetch(
+    "/api/observe/rollout/compare",
+    { key: "observe:rollout:compare", query }
+  );
+  const regressionsQuery = computed(() => ({
+    period: period.value,
+    ...serviceSlug.value ? { service: serviceSlug.value } : {}
+  }));
+  const regressionsFetch = useFetch(
+    "/api/observe/rollout/regressions",
+    { key: "observe:rollout:regressions", query: regressionsQuery, immediate: false, watch: false }
+  );
+  watch(
+    [serviceSlug, period],
+    () => {
+      if (serviceSlug.value) regressionsFetch.refresh();
+    },
+    { immediate: true }
+  );
+  const pending = computed(() => versionsFetch.pending.value || compareFetch.pending.value);
+  const error = computed(() => versionsFetch.error.value ?? compareFetch.error.value);
+  const refresh = async () => {
+    await Promise.all([
+      versionsFetch.refresh(),
+      compareFetch.refresh(),
+      ...serviceSlug.value ? [regressionsFetch.refresh()] : []
+    ]);
+  };
+  return {
+    versions: versionsFetch.data,
+    compare: compareFetch.data,
+    regressions: regressionsFetch.data,
+    hasService,
+    pending,
+    error,
+    refresh
+  };
+}

package/dist/runtime/app/composables/useObserveScope.d.ts

@@ -0,0 +1,13 @@
+import { type Ref, type ComputedRef } from 'vue';
+/**
+ * Selected observable: a service slug, 'group:<slug>', or null (= everything the
+ * caller is assigned). Cookie-persisted so the selection survives reloads. The value
+ * is presentational input only — the server re-validates any named slug against the
+ * caller's scope (404 unknown, 403 out-of-scope).
+ */
+export declare function useObserveScope(): {
+    scope: Ref<string | null>;
+    setScope: (value: string | null) => void;
+    serviceSlug: ComputedRef<string | undefined>;
+    groupSlug: ComputedRef<string | undefined>;
+};

package/dist/runtime/app/composables/useObserveScope.js

@@ -0,0 +1,17 @@
+import { computed } from "vue";
+import { useState, useCookie } from "#imports";
+export function useObserveScope() {
+  const cookie = useCookie("observe:scope", { default: () => null });
+  const scope = useState("observe:scope", () => cookie.value ?? null);
+  const setScope = (value) => {
+    scope.value = value;
+    cookie.value = value;
+  };
+  const serviceSlug = computed(
+    () => scope.value && !scope.value.startsWith("group:") ? scope.value : void 0
+  );
+  const groupSlug = computed(
+    () => scope.value?.startsWith("group:") ? scope.value.slice("group:".length) : void 0
+  );
+  return { scope, setScope, serviceSlug, groupSlug };
+}

package/dist/runtime/app/composables/useObserveServices.d.ts

@@ -0,0 +1,26 @@
+import type { Ref } from 'vue';
+import type { ServiceListItem, ServiceDetail, ServiceCreate, ServiceUpdate } from '../../shared/schema/provisioning.js';
+export interface UseObserveServicesReturn {
+    data: Ref<ServiceListItem[] | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+    create: (input: ServiceCreate) => Promise<ServiceDetail>;
+    update: (id: string, patch: ServiceUpdate) => Promise<ServiceDetail>;
+    softDelete: (id: string) => Promise<{
+        ok: true;
+        deletedAt: number;
+        purgeAt: number;
+    }>;
+    restore: (id: string) => Promise<ServiceDetail>;
+}
+/** The scoped services list plus the CRUD mutations behind the provisioning table. */
+export declare function useObserveServices(): UseObserveServicesReturn;
+export interface UseObserveServiceDetailReturn {
+    data: Ref<ServiceDetail | null | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | null | undefined>;
+    refresh: () => Promise<void>;
+}
+/** Single-service detail fetch keyed by id, for the edit page. */
+export declare function useObserveServiceDetail(id: string): UseObserveServiceDetailReturn;

package/dist/runtime/app/composables/useObserveServices.js

@@ -0,0 +1,33 @@
+import { useFetch } from "#imports";
+export function useObserveServices() {
+  const { data, pending, error, refresh } = useFetch(
+    "/api/observe/services",
+    { key: "observe:services" }
+  );
+  const create = (input) => $fetch("/api/observe/services", { method: "POST", body: input });
+  const update = (id, patch) => $fetch(`/api/observe/services/${id}`, { method: "PATCH", body: patch });
+  const softDelete = (id) => $fetch(`/api/observe/services/${id}`, { method: "DELETE" });
+  const restore = (id) => $fetch(`/api/observe/services/${id}/restore`, { method: "POST" });
+  return {
+    data,
+    pending,
+    error,
+    refresh,
+    create,
+    update,
+    softDelete,
+    restore
+  };
+}
+export function useObserveServiceDetail(id) {
+  const { data, pending, error, refresh } = useFetch(
+    `/api/observe/services/${id}`,
+    { key: `observe:service:${id}` }
+  );
+  return {
+    data,
+    pending,
+    error,
+    refresh
+  };
+}