@homeflare/alchemy 0.24.0 → 0.25.1

package/dist/paperless/index.js

@@ -0,0 +1,524 @@
+// src/paperless/credentials.ts
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+class PaperlessCredentialsError extends Data.TaggedError("PaperlessCredentialsError") {
+}
+var readEnvironment = Effect.suspend(() => {
+  const url = process.env["PAPERLESS_URL"];
+  const token = process.env["PAPERLESS_TOKEN"];
+  if (url === undefined || url.trim() === "") {
+    return Effect.fail(new PaperlessCredentialsError({
+      message: "PAPERLESS_URL is not set. Point it at your Paperless-ngx instance."
+    }));
+  }
+  if (token === undefined || token.trim() === "") {
+    return Effect.fail(new PaperlessCredentialsError({
+      message: "PAPERLESS_TOKEN is not set. Mint a scoped token and export it — never store it in Alchemy props."
+    }));
+  }
+  return Effect.succeed({ token: token.trim(), url: url.trim().replace(/\/$/, "") });
+});
+
+class PaperlessCredentials extends Context.Service()("PaperlessCredentials") {
+}
+var environmentLayer = Layer.succeed(PaperlessCredentials, readEnvironment);
+// src/paperless/errors.ts
+import * as Data2 from "effect/Data";
+
+class PaperlessNotFound extends Data2.TaggedError("PaperlessNotFound") {
+}
+
+class PaperlessUnauthorized extends Data2.TaggedError("PaperlessUnauthorized") {
+}
+
+class PaperlessValidation extends Data2.TaggedError("PaperlessValidation") {
+}
+
+class PaperlessUnavailable extends Data2.TaggedError("PaperlessUnavailable") {
+}
+var statusToError = (status, method, path, body) => {
+  if (status === 404)
+    return new PaperlessNotFound({ method, path });
+  if (status === 401 || status === 403)
+    return new PaperlessUnauthorized({ method, path, status });
+  if (status >= 500)
+    return new PaperlessUnavailable({ detail: body, method, path, status });
+  return new PaperlessValidation({ body, method, path });
+};
+// src/paperless/constraint-guard.ts
+import * as Effect2 from "effect/Effect";
+
+// src/paperless/constraints.ts
+var lengthOf = (value) => [...value].length;
+var checkString = (name, value, rule) => {
+  const out = [];
+  if (rule.maxLength !== undefined && lengthOf(value) > rule.maxLength) {
+    out.push(`${name}: at most ${String(rule.maxLength)} characters`);
+  }
+  if (rule.minLength !== undefined && lengthOf(value) < rule.minLength) {
+    out.push(`${name}: at least ${String(rule.minLength)} characters`);
+  }
+  if (rule.enum !== undefined && !rule.enum.includes(value)) {
+    out.push(`${name}: must be one of ${rule.enum.join(", ")}`);
+  }
+  if (rule.pattern !== undefined && !new RegExp(rule.pattern).test(value)) {
+    out.push(`${name}: must match ${rule.patternSource ?? rule.pattern}`);
+  }
+  return out;
+};
+var checkNumber = (name, value, rule) => {
+  const out = [];
+  if (!Number.isFinite(value))
+    return out;
+  if (rule.minimum !== undefined && value < rule.minimum)
+    out.push(`${name}: at least ${String(rule.minimum)}`);
+  if (rule.maximum !== undefined && value > rule.maximum)
+    out.push(`${name}: at most ${String(rule.maximum)}`);
+  return out;
+};
+var checkValue = (name, value, rule) => {
+  if (typeof value === "string")
+    return checkString(name, value, rule);
+  if (typeof value === "number")
+    return checkNumber(name, value, rule);
+  return [];
+};
+var violations = (table, body, options = {}) => {
+  const out = [];
+  for (const [name, rule] of Object.entries(table)) {
+    if (!Object.hasOwn(body, name)) {
+      if (options.presence === true && rule.required === true)
+        out.push(`${name}: required`);
+      continue;
+    }
+    const value = body[name];
+    for (const item of Array.isArray(value) ? value : [value])
+      out.push(...checkValue(name, item, rule));
+  }
+  return out;
+};
+var refusal = (endpoint, found) => `${endpoint} would be rejected by the vendor:
+  - ${found.join(`
+  - `)}
+` + "These are Paperless-ngx's own limits, read from its served OpenAPI document " + "(packages/alchemy/src/paperless/generated/constraints). Fix the declaration.";
+
+// src/paperless/generated/constraints/paperless-custom_fields.ts
+var PAPERLESS_CUSTOM_FIELDS_CONSTRAINTS = {
+  "paperless:PATCH /api/custom_fields/{id}/": {
+    name: { maxLength: 128, minLength: 1, type: "string" }
+  },
+  "paperless:POST /api/custom_fields/": {
+    data_type: { required: true },
+    name: { maxLength: 128, minLength: 1, required: true, type: "string" }
+  }
+};
+
+// src/paperless/generated/constraints/paperless-document_types.ts
+var PAPERLESS_DOCUMENT_TYPES_CONSTRAINTS = {
+  "paperless:PATCH /api/document_types/{id}/": {
+    match: { maxLength: 256, type: "string" },
+    matching_algorithm: { enum: [0, 1, 2, 3, 4, 5, 6], type: "integer" },
+    name: { maxLength: 128, minLength: 1, type: "string" }
+  },
+  "paperless:POST /api/document_types/": {
+    match: { maxLength: 256, type: "string" },
+    matching_algorithm: { enum: [0, 1, 2, 3, 4, 5, 6], type: "integer" },
+    name: { maxLength: 128, minLength: 1, required: true, type: "string" }
+  }
+};
+
+// src/paperless/generated/constraints/paperless-storage_paths.ts
+var PAPERLESS_STORAGE_PATHS_CONSTRAINTS = {
+  "paperless:PATCH /api/storage_paths/{id}/": {
+    match: { maxLength: 256, type: "string" },
+    matching_algorithm: { enum: [0, 1, 2, 3, 4, 5, 6], type: "integer" },
+    name: { maxLength: 128, minLength: 1, type: "string" },
+    path: { minLength: 1, type: "string" }
+  },
+  "paperless:POST /api/storage_paths/": {
+    match: { maxLength: 256, type: "string" },
+    matching_algorithm: { enum: [0, 1, 2, 3, 4, 5, 6], type: "integer" },
+    name: { maxLength: 128, minLength: 1, required: true, type: "string" },
+    path: { minLength: 1, required: true, type: "string" }
+  }
+};
+
+// src/paperless/generated/constraints/paperless-tags.ts
+var PAPERLESS_TAGS_CONSTRAINTS = {
+  "paperless:PATCH /api/tags/{id}/": {
+    color: { maxLength: 7, minLength: 1, type: "string" },
+    match: { maxLength: 256, type: "string" },
+    matching_algorithm: { enum: [0, 1, 2, 3, 4, 5, 6], type: "integer" },
+    name: { maxLength: 128, minLength: 1, type: "string" }
+  },
+  "paperless:POST /api/tags/": {
+    color: { maxLength: 7, minLength: 1, type: "string" },
+    match: { maxLength: 256, type: "string" },
+    matching_algorithm: { enum: [0, 1, 2, 3, 4, 5, 6], type: "integer" },
+    name: { maxLength: 128, minLength: 1, required: true, type: "string" }
+  }
+};
+
+// src/paperless/generated/constraints/index.ts
+var PAPERLESS_CONSTRAINTS = {
+  ...PAPERLESS_CUSTOM_FIELDS_CONSTRAINTS,
+  ...PAPERLESS_DOCUMENT_TYPES_CONSTRAINTS,
+  ...PAPERLESS_STORAGE_PATHS_CONSTRAINTS,
+  ...PAPERLESS_TAGS_CONSTRAINTS
+};
+var PAPERLESS_CONSTRAINTS_DIGEST = "66e61dce8c099d7d";
+
+// src/paperless/constraint-guard.ts
+var constraintsFor = (key) => {
+  const table = PAPERLESS_CONSTRAINTS[key];
+  if (table === undefined) {
+    throw new Error(`no vendor constraint table for '${key}'. It is named in this package but not generated: ` + "run `bun codegen/paperless.ts` (see codegen/README.md).");
+  }
+  return table;
+};
+var bodyViolations = (key, body, presence) => violations(constraintsFor(key), body, { presence });
+var guardBody = (key, body, presence) => Effect2.suspend(() => {
+  if (key === undefined)
+    return Effect2.void;
+  const found = bodyViolations(key, body, presence);
+  return found.length === 0 ? Effect2.void : Effect2.die(new Error(refusal(key, found)));
+});
+// src/paperless/tag.ts
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import * as Effect6 from "effect/Effect";
+
+// src/paperless/matching.ts
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Effect5 from "effect/Effect";
+
+// src/paperless/client.ts
+import * as Effect3 from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+var PATH_PREFIX = "/api";
+var API_VERSION = "10";
+var paperless = (method, path, body) => Effect3.gen(function* () {
+  const credentials = yield* yield* PaperlessCredentials;
+  const url = `${credentials.url}${PATH_PREFIX}/${path.replace(/^\//, "")}`;
+  const client = yield* HttpClient.HttpClient;
+  const request = HttpClientRequest.make(method)(url).pipe(HttpClientRequest.setHeaders({
+    Accept: `application/json; version=${API_VERSION}`,
+    Authorization: `Token ${credentials.token}`
+  }), body === undefined ? (self) => self : HttpClientRequest.bodyText(JSON.stringify(body), "application/json"));
+  const response = yield* client.execute(request).pipe(Effect3.mapError((cause) => new PaperlessUnavailable({ detail: String(cause), method, path, status: 0 })));
+  if (response.status < 200 || response.status >= 300) {
+    const detail = yield* response.text.pipe(Effect3.orElseSucceed(() => ""));
+    return yield* Effect3.fail(statusToError(response.status, method, path, detail.slice(0, 500)));
+  }
+  const text = yield* response.text.pipe(Effect3.mapError(() => new PaperlessUnavailable({
+    detail: "body read failed",
+    method,
+    path,
+    status: response.status
+  })));
+  return text === "" ? undefined : JSON.parse(text);
+});
+
+// src/paperless/matching-locate.ts
+import * as Effect4 from "effect/Effect";
+var absentOn404 = (io) => io.pipe(Effect4.catchIf((cause) => cause instanceof PaperlessNotFound, () => Effect4.succeed(undefined)));
+var LOCATE_PAGE = 20;
+var ownerOf = (row) => typeof row["owner"] === "number" ? row["owner"] : undefined;
+var matchingLocate = (spec) => {
+  const fetchByName = (props) => absentOn404(paperless("GET", `${spec.collection}/?name__iexact=${encodeURIComponent(props.name)}&page_size=${String(LOCATE_PAGE)}`)).pipe(Effect4.map((list) => {
+    if (list !== undefined && list.count > LOCATE_PAGE) {
+      throw new Error(`${spec.describe(props)}: name__iexact matched ${String(list.count)} rows, more than ` + `the ${String(LOCATE_PAGE)}-row page this reads. Narrow the name rather than paging.`);
+    }
+    const rows = (list?.results ?? []).filter((row) => row["name"] === props.name && ownerOf(row) === (props.owner ?? undefined));
+    if (rows.length > 1) {
+      throw new Error(`${spec.describe(props)}: matched ${String(rows.length)} Paperless objects with the same (name, owner).`);
+    }
+    return rows[0];
+  }));
+  const fetchById = (id) => absentOn404(paperless("GET", `${spec.collection}/${String(id)}/`));
+  const fetchLive = (props, output) => output === undefined ? fetchByName(props) : fetchById(output.id).pipe(Effect4.flatMap((live) => live === undefined ? Effect4.die(new Error(`${spec.describe(props)}: id ${String(output.id)} is recorded in state but no ` + "longer exists live (deleted out of band). Refusing to create a replacement " + "— adopt the live object back under this declaration, or remove it from " + "state, before deploying again.")) : Effect4.succeed(live)));
+  const objectPath = (live) => `${spec.collection}/${String(live["id"])}`;
+  return { fetchByName, fetchById, fetchLive, objectPath };
+};
+
+// src/paperless/matching.ts
+var sameValue = (a, b) => typeof a === "object" && a !== null ? JSON.stringify(a) === JSON.stringify(b) : Object.is(a, b);
+var matchingOperations = (spec) => {
+  const { fetchByName, fetchById, fetchLive, objectPath } = matchingLocate(spec);
+  const read = (props) => fetchByName(props).pipe(Effect5.map((live) => live === undefined ? undefined : spec.attributes(live, props)));
+  const readById = (props, id) => fetchById(id).pipe(Effect5.map((live) => live === undefined ? undefined : spec.attributes(live, props)));
+  const createBody = (props) => {
+    const out = spec.owned === false ? { name: props.name } : { name: props.name, owner: props.owner ?? null };
+    for (const field of [...spec.fields, ...spec.createOnly ?? []]) {
+      const value = field.prop(props);
+      if (value !== undefined)
+        out[field.key] = value;
+    }
+    return out;
+  };
+  const patchBody = (props, live) => {
+    const out = {};
+    if (props.name !== live["name"])
+      out["name"] = props.name;
+    if (spec.owned !== false && ownerOf(live) !== (props.owner ?? undefined)) {
+      out["owner"] = props.owner ?? null;
+    }
+    for (const field of spec.fields) {
+      const value = field.prop(props);
+      if (value !== undefined && !sameValue(value, field.live(live)))
+        out[field.key] = value;
+    }
+    return out;
+  };
+  const matches = (props, live) => {
+    if (props.name !== live["name"])
+      return false;
+    if (spec.owned !== false && ownerOf(live) !== (props.owner ?? undefined))
+      return false;
+    return spec.fields.every((field) => {
+      const value = field.prop(props);
+      return value === undefined || sameValue(value, field.live(live));
+    });
+  };
+  return {
+    read,
+    diff: (news, output) => Effect5.gen(function* () {
+      if (output === undefined || !isResolved(news))
+        return;
+      const live = yield* fetchLive(news, output);
+      if (live === undefined)
+        return { action: "update" };
+      const refusal2 = spec.immutable?.(live, news);
+      if (refusal2 !== undefined)
+        return yield* Effect5.die(new Error(refusal2));
+      if (matches(news, live))
+        return { action: "noop" };
+      return spec.endpoint.update === undefined ? { action: "replace" } : { action: "update" };
+    }),
+    reconcile: (news, output) => Effect5.gen(function* () {
+      const before = yield* fetchLive(news, output);
+      let id;
+      if (before === undefined) {
+        const body = createBody(news);
+        yield* guardBody(spec.endpoint.create, body, true);
+        yield* paperless("POST", `${spec.collection}/`, body);
+      } else {
+        id = typeof before["id"] === "number" ? before["id"] : undefined;
+        const refusal2 = spec.immutable?.(before, news);
+        if (refusal2 !== undefined)
+          return yield* Effect5.die(new Error(refusal2));
+        if (spec.endpoint.update !== undefined) {
+          const body = patchBody(news, before);
+          if (Object.keys(body).length > 0) {
+            yield* guardBody(spec.endpoint.update, body, false);
+            yield* paperless("PATCH", `${objectPath(before)}/`, body);
+          }
+        }
+      }
+      const after = yield* id === undefined ? read(news) : readById(news, id);
+      if (after === undefined) {
+        return yield* Effect5.die(new Error(`${spec.describe(news)}: the write returned no error but the object is still absent.`));
+      }
+      return after;
+    }),
+    destroy: (olds, output) => Effect5.gen(function* () {
+      const live = output === undefined ? yield* fetchByName(olds) : yield* fetchById(output.id);
+      if (live === undefined)
+        return;
+      yield* absentOn404(paperless("DELETE", `${objectPath(live)}/`));
+    })
+  };
+};
+var matchingHandlers = (spec) => {
+  const ops = matchingOperations(spec);
+  return {
+    list: () => Effect5.succeed([]),
+    read: ({ olds }) => ops.read(olds).pipe(Effect5.map((attrs) => attrs === undefined ? undefined : Unowned(attrs))),
+    diff: ({ news, output }) => ops.diff(news, output),
+    reconcile: ({ news, output }) => ops.reconcile(news, output),
+    delete: ({ olds, output }) => ops.destroy(olds, output)
+  };
+};
+
+// src/paperless/tag.ts
+var Tag = Resource("Paperless.Tag", { defaultRemovalPolicy: "retain" });
+var handlers = matchingHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    return {
+      color: typeof live["color"] === "string" ? live["color"] : "",
+      id,
+      isInboxTag: live["is_inbox_tag"] === true,
+      isInsensitive: live["is_insensitive"] === true,
+      match: typeof live["match"] === "string" ? live["match"] : "",
+      matchingAlgorithm: typeof live["matching_algorithm"] === "number" ? live["matching_algorithm"] : 0,
+      name: typeof live["name"] === "string" ? live["name"] : props.name,
+      owner: typeof live["owner"] === "number" ? live["owner"] : undefined,
+      parent: typeof live["parent"] === "number" ? live["parent"] : undefined
+    };
+  },
+  collection: "tags",
+  describe: (props) => `tags ${props.name}`,
+  endpoint: { create: "paperless:POST /api/tags/", update: "paperless:PATCH /api/tags/{id}/" },
+  fields: [
+    { key: "color", live: (r) => r["color"], prop: (p) => p.color },
+    { key: "match", live: (r) => r["match"], prop: (p) => p.match },
+    {
+      key: "matching_algorithm",
+      live: (r) => r["matching_algorithm"],
+      prop: (p) => p.matchingAlgorithm
+    },
+    { key: "is_insensitive", live: (r) => r["is_insensitive"], prop: (p) => p.isInsensitive },
+    { key: "is_inbox_tag", live: (r) => r["is_inbox_tag"], prop: (p) => p.isInboxTag },
+    { key: "parent", live: (r) => r["parent"], prop: (p) => p.parent }
+  ]
+});
+var TagProvider = () => Provider.effect(Tag, Effect6.succeed(Tag.Provider.of(handlers)));
+// src/paperless/document-type.ts
+import { Resource as Resource2 } from "alchemy";
+import * as Provider2 from "alchemy/Provider";
+import * as Effect7 from "effect/Effect";
+var DocumentType = Resource2("Paperless.DocumentType", {
+  defaultRemovalPolicy: "retain"
+});
+var handlers2 = matchingHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    return {
+      id,
+      isInsensitive: live["is_insensitive"] === true,
+      match: typeof live["match"] === "string" ? live["match"] : "",
+      matchingAlgorithm: typeof live["matching_algorithm"] === "number" ? live["matching_algorithm"] : 0,
+      name: typeof live["name"] === "string" ? live["name"] : props.name,
+      owner: typeof live["owner"] === "number" ? live["owner"] : undefined
+    };
+  },
+  collection: "document_types",
+  describe: (props) => `document_types ${props.name}`,
+  endpoint: {
+    create: "paperless:POST /api/document_types/",
+    update: "paperless:PATCH /api/document_types/{id}/"
+  },
+  fields: [
+    { key: "match", live: (r) => r["match"], prop: (p) => p.match },
+    {
+      key: "matching_algorithm",
+      live: (r) => r["matching_algorithm"],
+      prop: (p) => p.matchingAlgorithm
+    },
+    { key: "is_insensitive", live: (r) => r["is_insensitive"], prop: (p) => p.isInsensitive }
+  ]
+});
+var DocumentTypeProvider = () => Provider2.effect(DocumentType, Effect7.succeed(DocumentType.Provider.of(handlers2)));
+// src/paperless/storage-path.ts
+import { Resource as Resource3 } from "alchemy";
+import * as Provider3 from "alchemy/Provider";
+import * as Effect8 from "effect/Effect";
+var StoragePath = Resource3("Paperless.StoragePath", {
+  defaultRemovalPolicy: "retain"
+});
+var handlers3 = matchingHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    return {
+      id,
+      isInsensitive: live["is_insensitive"] === true,
+      match: typeof live["match"] === "string" ? live["match"] : "",
+      matchingAlgorithm: typeof live["matching_algorithm"] === "number" ? live["matching_algorithm"] : 0,
+      name: typeof live["name"] === "string" ? live["name"] : props.name,
+      owner: typeof live["owner"] === "number" ? live["owner"] : undefined,
+      path: typeof live["path"] === "string" ? live["path"] : props.path
+    };
+  },
+  collection: "storage_paths",
+  describe: (props) => `storage_paths ${props.name}`,
+  endpoint: {
+    create: "paperless:POST /api/storage_paths/",
+    update: "paperless:PATCH /api/storage_paths/{id}/"
+  },
+  fields: [
+    { key: "path", live: (r) => r["path"], prop: (p) => p.path },
+    { key: "match", live: (r) => r["match"], prop: (p) => p.match },
+    {
+      key: "matching_algorithm",
+      live: (r) => r["matching_algorithm"],
+      prop: (p) => p.matchingAlgorithm
+    },
+    { key: "is_insensitive", live: (r) => r["is_insensitive"], prop: (p) => p.isInsensitive }
+  ]
+});
+var StoragePathProvider = () => Provider3.effect(StoragePath, Effect8.succeed(StoragePath.Provider.of(handlers3)));
+// src/paperless/custom-field.ts
+import { Resource as Resource4 } from "alchemy";
+import * as Provider4 from "alchemy/Provider";
+import * as Effect9 from "effect/Effect";
+var CustomField = Resource4("Paperless.CustomField", {
+  defaultRemovalPolicy: "retain"
+});
+var dataTypeImmutable = (live, props) => typeof live["data_type"] === "string" && live["data_type"] !== props.dataType ? `Paperless.CustomField "${props.name}": data_type is create-only (live: ${live["data_type"]}, ` + `declared: ${props.dataType}). Changing it would delete this field's value on every ` + "document. Create a new custom field instead, and retire this one by hand." : undefined;
+var customFieldHandlers = matchingHandlers({
+  attributes: (live, props) => {
+    const id = live["id"];
+    if (typeof id !== "number")
+      return;
+    return {
+      dataType: typeof live["data_type"] === "string" ? live["data_type"] : props.dataType,
+      extraData: live["extra_data"],
+      id,
+      name: typeof live["name"] === "string" ? live["name"] : props.name
+    };
+  },
+  collection: "custom_fields",
+  describe: (props) => `custom_fields ${props.name}`,
+  endpoint: {
+    create: "paperless:POST /api/custom_fields/",
+    update: "paperless:PATCH /api/custom_fields/{id}/"
+  },
+  createOnly: [{ key: "data_type", live: (r) => r["data_type"], prop: (p) => p.dataType }],
+  fields: [{ key: "extra_data", live: (r) => r["extra_data"], prop: (p) => p.extraData }],
+  immutable: dataTypeImmutable,
+  owned: false
+});
+var CustomFieldProvider = () => Provider4.effect(CustomField, Effect9.succeed(CustomField.Provider.of(customFieldHandlers)));
+// src/paperless/providers.ts
+import * as Layer2 from "effect/Layer";
+var paperlessProviders = (credentials = environmentLayer) => Layer2.mergeAll(TagProvider(), DocumentTypeProvider(), StoragePathProvider(), CustomFieldProvider()).pipe(Layer2.provide(credentials));
+export {
+  CustomField,
+  CustomFieldProvider,
+  DocumentType,
+  DocumentTypeProvider,
+  PAPERLESS_CONSTRAINTS,
+  PAPERLESS_CONSTRAINTS_DIGEST,
+  PaperlessCredentials,
+  PaperlessCredentialsError,
+  PaperlessNotFound,
+  PaperlessUnauthorized,
+  PaperlessUnavailable,
+  PaperlessValidation,
+  StoragePath,
+  StoragePathProvider,
+  Tag,
+  TagProvider,
+  bodyViolations,
+  constraintsFor,
+  guardBody,
+  environmentLayer as paperlessEnvironmentLayer,
+  paperlessProviders,
+  refusal,
+  violations
+};
+
+//# debugId=EE28611444A13F1E64756E2164756E21
+//# sourceMappingURL=index.js.map