@homeflare/alchemy 0.32.0 → 0.34.0

package/dist/grafana/index.js

@@ -2,8 +2,7 @@
 import { Resource } from "alchemy";
 import * as Provider from "alchemy/Provider";
 import * as grafana from "@distilled.cloud/grafana";
-import * as Data from "effect/Data";
-import * as Effect2 from "effect/Effect";
+import * as Effect3 from "effect/Effect";
 
 // src/grafana/resource.ts
 import { isResolved } from "alchemy/Diff";
@@ -57,12 +56,13 @@ var grafanaHandlers = (spec) => {
   };
 };
 
-// src/grafana/datasource.ts
-var GrafanaDatasource = Resource("Grafana.Datasource");
+// src/grafana/secret-refs.ts
+import * as Data from "effect/Data";
+import * as Effect2 from "effect/Effect";
 
 class GrafanaSecretRefUnsetError extends Data.TaggedError("GrafanaSecretRefUnsetError") {
 }
-var resolveSecureJsonData = (refs) => Effect2.gen(function* () {
+var resolveSecretRefs = (refs, describeField) => Effect2.gen(function* () {
   if (refs === undefined)
     return;
   const out = {};
@@ -70,13 +70,17 @@ var resolveSecureJsonData = (refs) => Effect2.gen(function* () {
     const raw = process.env[envVar];
     if (raw === undefined || raw.trim() === "") {
       return yield* Effect2.fail(new GrafanaSecretRefUnsetError({
-        message: `${envVar} is unset. Export the value of secureJsonData.${field} there — ` + "never as an Alchemy prop."
+        message: `${envVar} is unset. Export the value of ${describeField(field)} there — ` + "never as an Alchemy prop."
       }));
     }
     out[field] = raw.trim();
   }
   return out;
 });
+
+// src/grafana/datasource.ts
+var GrafanaDatasource = Resource("Grafana.Datasource");
+var resolveSecureJsonData = (refs) => resolveSecretRefs(refs, (field) => `secureJsonData.${field}`);
 var fields = (props) => ({
   name: props.name,
   type: props.type,
@@ -103,15 +107,15 @@ var spec = {
     url: live.url ?? "",
     version: live.version ?? 0
   }),
-  create: (props) => Effect2.flatMap(resolveSecureJsonData(props.secureJsonDataRefs), (secureJsonData) => grafana.addDataSource({
+  create: (props) => Effect3.flatMap(resolveSecureJsonData(props.secureJsonDataRefs), (secureJsonData) => grafana.addDataSource({
     ...fields(props),
     ...secureJsonData === undefined ? {} : { secureJsonData },
     uid: props.uid
   })),
   destroy: (props) => grafana.deleteDataSourceByUID({ uid: props.uid }),
-  fetchLive: (props) => grafana.getDataSourceByUID({ uid: props.uid }).pipe(Effect2.catchTag("NotFound", () => Effect2.succeed(undefined))),
+  fetchLive: (props) => grafana.getDataSourceByUID({ uid: props.uid }).pipe(Effect3.catchTag("NotFound", () => Effect3.succeed(undefined))),
   matches: (attributes, props) => (props.name === undefined || attributes.name === props.name) && (props.type === undefined || attributes.type === props.type) && (props.url === undefined || attributes.url === props.url) && (props.access === undefined || attributes.access === props.access) && (props.isDefault === undefined || attributes.isDefault === props.isDefault),
-  update: (props, live) => Effect2.flatMap(resolveSecureJsonData(props.secureJsonDataRefs), (secureJsonData) => grafana.updateDataSourceByUID({
+  update: (props, live) => Effect3.flatMap(resolveSecureJsonData(props.secureJsonDataRefs), (secureJsonData) => grafana.updateDataSourceByUID({
     ...fields(props),
     ...secureJsonData === undefined ? {} : { secureJsonData },
     ...live.version === undefined ? {} : { version: live.version },
@@ -119,31 +123,336 @@ var spec = {
   }))
 };
 var handlers = grafanaHandlers(spec);
-var GrafanaDatasourceProvider = () => Provider.effect(GrafanaDatasource, Effect2.succeed(GrafanaDatasource.Provider.of(handlers)));
+var GrafanaDatasourceProvider = () => Provider.effect(GrafanaDatasource, Effect3.succeed(GrafanaDatasource.Provider.of(handlers)));
+// src/grafana/dashboard.ts
+import { Resource as Resource2 } from "alchemy";
+import * as Provider2 from "alchemy/Provider";
+import * as grafana2 from "@distilled.cloud/grafana";
+import * as Effect5 from "effect/Effect";
+
+// src/grafana/subset-match.ts
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var declaredContentMatches = (declared, live) => {
+  if (declared == null)
+    return true;
+  if (Array.isArray(declared)) {
+    return Array.isArray(live) && declared.length === live.length && declared.every((item, index) => declaredContentMatches(item, live[index]));
+  }
+  if (isPlainObject(declared)) {
+    return isPlainObject(live) && Object.entries(declared).every(([key, value]) => declaredContentMatches(value, live[key]));
+  }
+  return declared === live;
+};
+
+// src/grafana/dashboard-model.ts
+var VOLATILE_FIELDS = ["id", "version", "iteration"];
+var normalizeModel = (model, uid) => {
+  const normalized = {};
+  for (const [key, value] of Object.entries(model)) {
+    if (key === "uid")
+      continue;
+    if (VOLATILE_FIELDS.includes(key))
+      continue;
+    normalized[key] = value;
+  }
+  normalized.uid = uid;
+  return normalized;
+};
+var modelTitle = (model) => typeof model.title === "string" ? model.title : "";
+
+// src/grafana/provisioned.ts
+import * as Data2 from "effect/Data";
+import * as Effect4 from "effect/Effect";
+
+class GrafanaProvisionedObjectError extends Data2.TaggedError("GrafanaProvisionedObjectError") {
+}
+var refuseIfProvisioned = (kind, uid, owner) => {
+  const ownerClause = owner === undefined || owner === "" ? `(this Grafana instance did not report an owning file)` : `by ${owner}`;
+  return Effect4.fail(new GrafanaProvisionedObjectError({
+    message: `${kind} '${uid}' is file-provisioned ${ownerClause} and read-only through the classic ` + `write API this family calls. Edit the provisioning file instead — declaring this ` + `object read-only (a declaration matching what is live) is safe and will never reach ` + `this refusal.`
+  }));
+};
+
+// src/grafana/dashboard.ts
+var GrafanaDashboard = Resource2("Grafana.Dashboard");
+var modelOf = (live) => live.dashboard !== null && typeof live.dashboard === "object" ? live.dashboard : {};
+var spec2 = {
+  attributes: (live, props) => {
+    const model = normalizeModel(modelOf(live), props.uid);
+    return {
+      dashboard: model,
+      folderUid: live.meta?.folderUid ?? "",
+      provisioned: live.meta?.provisioned ?? false,
+      provisionedExternalId: live.meta?.provisionedExternalId ?? "",
+      title: modelTitle(model),
+      uid: props.uid,
+      url: live.meta?.url ?? "",
+      version: live.meta?.version ?? 0
+    };
+  },
+  create: (props) => grafana2.postDashboard({
+    dashboard: normalizeModel(props.dashboard, props.uid),
+    ...props.folderUid === undefined ? {} : { folderUid: props.folderUid }
+  }),
+  destroy: (props, live) => Effect5.gen(function* () {
+    if (live.meta?.provisioned) {
+      return yield* refuseIfProvisioned("Grafana.Dashboard", props.uid, live.meta.provisionedExternalId);
+    }
+    yield* grafana2.deleteDashboard({ uid: props.uid });
+  }),
+  fetchLive: (props) => grafana2.getDashboard({ uid: props.uid }).pipe(Effect5.catchTag("NotFound", () => Effect5.succeed(undefined))),
+  matches: (attributes, props) => (props.folderUid === undefined || attributes.folderUid === props.folderUid) && declaredContentMatches(normalizeModel(props.dashboard, props.uid), attributes.dashboard),
+  update: (props, live) => Effect5.gen(function* () {
+    if (live.meta?.provisioned) {
+      return yield* refuseIfProvisioned("Grafana.Dashboard", props.uid, live.meta.provisionedExternalId);
+    }
+    return yield* grafana2.postDashboard({
+      dashboard: {
+        ...normalizeModel(props.dashboard, props.uid),
+        ...live.meta?.version === undefined ? {} : { version: live.meta.version }
+      },
+      ...props.folderUid === undefined ? {} : { folderUid: props.folderUid }
+    });
+  })
+};
+var handlers2 = grafanaHandlers(spec2);
+var GrafanaDashboardProvider = () => Provider2.effect(GrafanaDashboard, Effect5.succeed(GrafanaDashboard.Provider.of(handlers2)));
+// src/grafana/folder.ts
+import { Resource as Resource3 } from "alchemy";
+import * as Provider3 from "alchemy/Provider";
+import * as grafana3 from "@distilled.cloud/grafana";
+import * as Data3 from "effect/Data";
+import * as Effect6 from "effect/Effect";
+var GrafanaFolder = Resource3("Grafana.Folder", {
+  defaultRemovalPolicy: "retain"
+});
+
+class GrafanaFolderReparentError extends Data3.TaggedError("GrafanaFolderReparentError") {
+}
+var spec3 = {
+  attributes: (live) => ({
+    id: live.id ?? 0,
+    managedBy: live.managedBy ?? "",
+    parentUid: live.parentUid ?? "",
+    title: live.title ?? "",
+    uid: live.uid ?? "",
+    url: live.url ?? "",
+    version: live.version ?? 0
+  }),
+  create: (props) => grafana3.createFolder({
+    uid: props.uid,
+    title: props.title,
+    ...props.description === undefined ? {} : { description: props.description },
+    ...props.parentUid === undefined ? {} : { parentUid: props.parentUid }
+  }),
+  destroy: (props, live) => Effect6.gen(function* () {
+    if (live.managedBy) {
+      return yield* refuseIfProvisioned("Grafana.Folder", props.uid, live.managedBy);
+    }
+    yield* grafana3.deleteFolder({ folder_uid: props.uid });
+  }),
+  fetchLive: (props) => grafana3.getFolderByUID({ folder_uid: props.uid }).pipe(Effect6.catchTag("NotFound", () => Effect6.succeed(undefined))),
+  matches: (attributes, props) => attributes.title === props.title && (props.parentUid === undefined || attributes.parentUid === props.parentUid),
+  update: (props, live) => Effect6.gen(function* () {
+    if (live.managedBy) {
+      return yield* refuseIfProvisioned("Grafana.Folder", props.uid, live.managedBy);
+    }
+    if (props.parentUid !== undefined && props.parentUid !== (live.parentUid ?? undefined)) {
+      return yield* Effect6.fail(new GrafanaFolderReparentError({
+        message: `Grafana.Folder '${props.uid}' declares parentUid '${props.parentUid}' but is ` + `live under '${live.parentUid ?? "(root)"}'. PUT /folders/{uid} cannot reparent a ` + `folder — move it by hand in Grafana, then update the declaration to match.`
+      }));
+    }
+    return yield* grafana3.updateFolder({
+      folder_uid: props.uid,
+      title: props.title,
+      ...props.description === undefined ? {} : { description: props.description },
+      ...live.version === undefined ? {} : { version: live.version }
+    });
+  })
+};
+var handlers3 = grafanaHandlers(spec3);
+var GrafanaFolderProvider = () => Provider3.effect(GrafanaFolder, Effect6.succeed(GrafanaFolder.Provider.of(handlers3)));
+// src/grafana/contact-point.ts
+import { Resource as Resource4 } from "alchemy";
+import * as Provider4 from "alchemy/Provider";
+import * as grafana4 from "@distilled.cloud/grafana";
+import * as Effect8 from "effect/Effect";
+
+// src/grafana/alerting-provenance.ts
+import * as Effect7 from "effect/Effect";
+var WRITABLE_PROVENANCES = new Set(["", "api"]);
+var isForeignProvenance = (provenance) => provenance === undefined || !WRITABLE_PROVENANCES.has(provenance);
+var refuseIfForeignProvenance = (kind, id, provenance) => {
+  const reason = provenance === undefined ? `did not report a provenance at all — this family cannot tell whether it is safe to own` : `has provenance '${provenance}', not '(none)' or 'api'`;
+  return Effect7.fail(new GrafanaProvisionedObjectError({
+    message: `${kind} '${id}' ${reason} — something other than this API may own it (file ` + `provisioning, the Prometheus-rules importer, or similar), and writing here could take ` + `over or corrupt an object this family does not actually control. Edit it at its actual ` + `source instead — declaring this object read-only (a declaration matching what is live) ` + `is safe and will never reach this refusal.`
+  }));
+};
+
+// src/grafana/contact-point.ts
+var GrafanaContactPoint = Resource4("Grafana.ContactPoint");
+var nonSecretSettings = (props) => {
+  const refs = props.secureSettingsRefs;
+  if (refs === undefined)
+    return props.settings;
+  const out = {};
+  for (const [key, value] of Object.entries(props.settings)) {
+    if (!(key in refs))
+      out[key] = value;
+  }
+  return out;
+};
+var resolveSettings = (props) => Effect8.map(resolveSecretRefs(props.secureSettingsRefs, (field) => `settings.${field}`), (secrets) => secrets === undefined ? props.settings : { ...props.settings, ...secrets });
+var spec4 = {
+  attributes: (live) => ({
+    disableResolveMessage: live.disableResolveMessage ?? false,
+    name: live.name ?? "",
+    provenance: live.provenance,
+    settings: live.settings ?? {},
+    type: live.type,
+    uid: live.uid ?? ""
+  }),
+  create: (props) => Effect8.flatMap(resolveSettings(props), (settings) => grafana4.routePostContactpoints({
+    name: props.name,
+    settings,
+    type: props.type,
+    uid: props.uid,
+    ...props.disableResolveMessage === undefined ? {} : { disableResolveMessage: props.disableResolveMessage }
+  })),
+  destroy: (props, live) => Effect8.gen(function* () {
+    if (isForeignProvenance(live.provenance)) {
+      return yield* refuseIfForeignProvenance("Grafana.ContactPoint", props.uid, live.provenance);
+    }
+    yield* grafana4.routeDeleteContactpoints({ UID: props.uid });
+  }),
+  fetchLive: (props) => grafana4.routeGetContactpoints({}).pipe(Effect8.map((points) => points.find((point) => point.uid === props.uid))),
+  matches: (attributes, props) => attributes.name === props.name && attributes.type === props.type && attributes.disableResolveMessage === (props.disableResolveMessage ?? false) && declaredContentMatches(nonSecretSettings(props), attributes.settings),
+  update: (props, live) => Effect8.gen(function* () {
+    if (isForeignProvenance(live.provenance)) {
+      return yield* refuseIfForeignProvenance("Grafana.ContactPoint", props.uid, live.provenance);
+    }
+    const settings = yield* resolveSettings(props);
+    yield* grafana4.routePutContactpoint({
+      UID: props.uid,
+      name: props.name,
+      settings,
+      type: props.type,
+      uid: props.uid,
+      ...props.disableResolveMessage === undefined ? {} : { disableResolveMessage: props.disableResolveMessage }
+    });
+  })
+};
+var handlers4 = grafanaHandlers(spec4);
+var GrafanaContactPointProvider = () => Provider4.effect(GrafanaContactPoint, Effect8.succeed(GrafanaContactPoint.Provider.of(handlers4)));
+// src/grafana/message-template.ts
+import { Resource as Resource5 } from "alchemy";
+import * as Provider5 from "alchemy/Provider";
+import * as grafana5 from "@distilled.cloud/grafana";
+import * as Effect9 from "effect/Effect";
+var GrafanaMessageTemplate = Resource5("Grafana.MessageTemplate");
+var spec5 = {
+  attributes: (live) => ({
+    name: live.name ?? "",
+    provenance: live.provenance,
+    template: live.template ?? ""
+  }),
+  create: (props) => grafana5.routePutTemplate({ name: props.name, template: props.template }),
+  destroy: (props, live) => Effect9.gen(function* () {
+    if (isForeignProvenance(live.provenance)) {
+      return yield* refuseIfForeignProvenance("Grafana.MessageTemplate", props.name, live.provenance);
+    }
+    yield* grafana5.routeDeleteTemplate({ name: props.name });
+  }),
+  fetchLive: (props) => grafana5.routeGetTemplate({ name: props.name }).pipe(Effect9.catchTag("NotFound", () => Effect9.succeed(undefined))),
+  matches: (attributes, props) => attributes.template === props.template,
+  update: (props, live) => Effect9.gen(function* () {
+    if (isForeignProvenance(live.provenance)) {
+      return yield* refuseIfForeignProvenance("Grafana.MessageTemplate", props.name, live.provenance);
+    }
+    yield* grafana5.routePutTemplate({
+      name: props.name,
+      template: props.template,
+      ...live.version === undefined ? {} : { version: live.version }
+    });
+  })
+};
+var handlers5 = grafanaHandlers(spec5);
+var GrafanaMessageTemplateProvider = () => Provider5.effect(GrafanaMessageTemplate, Effect9.succeed(GrafanaMessageTemplate.Provider.of(handlers5)));
+// src/grafana/mute-timing.ts
+import { Resource as Resource6 } from "alchemy";
+import * as Provider6 from "alchemy/Provider";
+import * as grafana6 from "@distilled.cloud/grafana";
+import * as Effect10 from "effect/Effect";
+var GrafanaMuteTiming = Resource6("Grafana.MuteTiming");
+var spec6 = {
+  attributes: (live) => ({
+    name: live.name ?? "",
+    provenance: live.provenance,
+    timeIntervals: live.time_intervals ?? []
+  }),
+  create: (props) => grafana6.routePostMuteTiming({
+    name: props.name,
+    time_intervals: props.timeIntervals
+  }),
+  destroy: (props, live) => Effect10.gen(function* () {
+    if (isForeignProvenance(live.provenance)) {
+      return yield* refuseIfForeignProvenance("Grafana.MuteTiming", props.name, live.provenance);
+    }
+    yield* grafana6.routeDeleteMuteTiming({
+      name: props.name,
+      ...live.version === undefined ? {} : { version: live.version }
+    });
+  }),
+  fetchLive: (props) => grafana6.routeGetMuteTiming({ name: props.name }).pipe(Effect10.map((live) => live), Effect10.catchTag("NotFound", () => Effect10.succeed(undefined))),
+  matches: (attributes, props) => declaredContentMatches(props.timeIntervals, attributes.timeIntervals),
+  update: (props, live) => Effect10.gen(function* () {
+    if (isForeignProvenance(live.provenance)) {
+      return yield* refuseIfForeignProvenance("Grafana.MuteTiming", props.name, live.provenance);
+    }
+    yield* grafana6.routePutMuteTiming({
+      name: props.name,
+      time_intervals: props.timeIntervals
+    });
+  })
+};
+var handlers6 = grafanaHandlers(spec6);
+var GrafanaMuteTimingProvider = () => Provider6.effect(GrafanaMuteTiming, Effect10.succeed(GrafanaMuteTiming.Provider.of(handlers6)));
 // src/grafana/credentials.ts
 import { Credentials } from "@distilled.cloud/grafana/Credentials";
 import { ConfigError } from "@distilled.cloud/grafana/Errors";
-import * as Effect3 from "effect/Effect";
+import * as Effect11 from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
-var resolve = (target) => Effect3.sync(() => process.env[target.tokenEnv]).pipe(Effect3.flatMap((raw) => raw === undefined || raw.trim() === "" ? Effect3.fail(new ConfigError({
+var resolve = (target) => Effect11.sync(() => process.env[target.tokenEnv]).pipe(Effect11.flatMap((raw) => raw === undefined || raw.trim() === "" ? Effect11.fail(new ConfigError({
   message: `${target.tokenEnv} is not set. Export the Grafana service-account token there ` + `— never as an Alchemy prop — before running a stack that declares a resource ` + `against ${target.baseUrl}.`
-})) : Effect3.succeed({
+})) : Effect11.succeed({
   apiBaseUrl: target.baseUrl.replace(/\/+$/, ""),
   token: Redacted.make(raw.trim()),
   ...target.orgId === undefined ? {} : { orgId: target.orgId }
-})), Effect3.orDie);
+})), Effect11.orDie);
 var grafanaCredentials = (target) => Layer.succeed(Credentials, resolve(target));
 // src/grafana/providers.ts
 import * as Layer2 from "effect/Layer";
-var grafanaProviders = (target) => GrafanaDatasourceProvider().pipe(Layer2.provide(grafanaCredentials(target)));
+var grafanaProviders = (target) => Layer2.mergeAll(GrafanaDatasourceProvider(), GrafanaFolderProvider(), GrafanaDashboardProvider(), GrafanaContactPointProvider(), GrafanaMuteTimingProvider(), GrafanaMessageTemplateProvider()).pipe(Layer2.provide(grafanaCredentials(target)));
 export {
+  GrafanaContactPoint,
+  GrafanaContactPointProvider,
+  GrafanaDashboard,
+  GrafanaDashboardProvider,
   GrafanaDatasource,
   GrafanaDatasourceProvider,
+  GrafanaFolder,
+  GrafanaFolderProvider,
+  GrafanaFolderReparentError,
+  GrafanaMessageTemplate,
+  GrafanaMessageTemplateProvider,
+  GrafanaMuteTiming,
+  GrafanaMuteTimingProvider,
+  GrafanaProvisionedObjectError,
   GrafanaSecretRefUnsetError,
   grafanaCredentials,
   grafanaProviders
 };
 
-//# debugId=DA921F3915B68A6164756E2164756E21
+//# debugId=D93AD79265681B5F64756E2164756E21
 //# sourceMappingURL=index.js.map