@relyio/sdk 0.17.0 → 0.18.0

package/dist/chunk-L6DXCKVQ.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+exports.__commonJS = __commonJS;
+exports.__export = __export;
+exports.__name = __name;
+exports.__publicField = __publicField;
+exports.__require = __require;
+exports.__toESM = __toESM;
+//# sourceMappingURL=chunk-L6DXCKVQ.cjs.map
+//# sourceMappingURL=chunk-L6DXCKVQ.cjs.map

package/dist/chunk-LSI26ZN2.cjs

@@ -0,0 +1,535 @@
+'use strict';
+
+var chunkZAMAR3X2_cjs = require('./chunk-ZAMAR3X2.cjs');
+var chunkL6DXCKVQ_cjs = require('./chunk-L6DXCKVQ.cjs');
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/automations/index.ts
+var REF = /* @__PURE__ */ Symbol("relyio.automation.ref");
+var TEMPLATE = /* @__PURE__ */ Symbol("relyio.automation.template");
+var TESTS = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "exists",
+  "isNull",
+  "isEmpty",
+  "hasValue",
+  "contains",
+  "notContains",
+  "between"
+]);
+function refAt(root, path, becomes) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, key) {
+      if (key === REF) return { kind: "ref", root, path };
+      if (typeof key !== "string" || key === "then") return void 0;
+      if (TESTS.has(key)) return chunkZAMAR3X2_cjs.conditionRoot(root, path)[key];
+      if (becomes && key === "becomes") {
+        return (value) => ({
+          root: "event",
+          path,
+          operator: "becomes",
+          value
+        });
+      }
+      return refAt(root, [...path, key], becomes);
+    }
+  });
+}
+chunkL6DXCKVQ_cjs.__name(refAt, "refAt");
+function refOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const held = value[REF];
+  return held === void 0 ? void 0 : held;
+}
+chunkL6DXCKVQ_cjs.__name(refOf, "refOf");
+function tpl(strings, ...values) {
+  const parts = [];
+  const literal = /* @__PURE__ */ chunkL6DXCKVQ_cjs.__name((text) => {
+    const last = parts[parts.length - 1];
+    if (typeof last === "string") parts[parts.length - 1] = last + text;
+    else if (text !== "") parts.push(text);
+  }, "literal");
+  for (const [index, text] of strings.entries()) {
+    literal(text);
+    if (index >= values.length) continue;
+    const value = values[index];
+    const ref = refOf(value);
+    if (ref === void 0) literal(String(value));
+    else parts.push(ref);
+  }
+  return { [TEMPLATE]: parts };
+}
+chunkL6DXCKVQ_cjs.__name(tpl, "tpl");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+chunkL6DXCKVQ_cjs.__name(isPlainObject, "isPlainObject");
+function valueOf(value, at) {
+  const ref = refOf(value);
+  if (ref !== void 0) return ref;
+  if (typeof value === "object" && value !== null && TEMPLATE in value) {
+    return { kind: "template", parts: [...value[TEMPLATE]] };
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item, index) => valueOf(item, `${at}[${index}]`));
+    return items.every((item) => item.kind === "literal") ? { kind: "literal", value: items.map((item) => item.value) } : { kind: "list", items };
+  }
+  if (isPlainObject(value)) {
+    const entries2 = Object.entries(value).filter(([, held]) => held !== void 0).map(([key, held]) => [key, valueOf(held, `${at}.${key}`)]);
+    return entries2.every(([, held]) => held.kind === "literal") ? {
+      kind: "literal",
+      value: Object.fromEntries(
+        entries2.map(([key, held]) => [key, held.value])
+      )
+    } : { kind: "object", fields: Object.fromEntries(entries2) };
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return { kind: "literal", value };
+  }
+  throw new TypeError(
+    `${at} is ${typeof value}: a step is handed data \u2014 a value, a reference or tpl\`\u2026\` \u2014 never code`
+  );
+}
+chunkL6DXCKVQ_cjs.__name(valueOf, "valueOf");
+function inputOf(input, at) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0).map(([key, value]) => [key, valueOf(value, `${at}.${key}`)])
+  );
+}
+chunkL6DXCKVQ_cjs.__name(inputOf, "inputOf");
+function and(...conditions) {
+  return { and: conditions };
+}
+chunkL6DXCKVQ_cjs.__name(and, "and");
+function or(...conditions) {
+  return { or: conditions };
+}
+chunkL6DXCKVQ_cjs.__name(or, "or");
+function not(condition) {
+  return { not: condition };
+}
+chunkL6DXCKVQ_cjs.__name(not, "not");
+var FIELD_OPERATORS = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "exists"];
+function whereOf(where, item) {
+  if (typeof where === "function") {
+    return where(refAt("event", [], true));
+  }
+  if (!isPlainObject(where)) {
+    throw new TypeError(
+      "A where is { field: value | { becomes, eq, \u2026 } }, or a function of the event"
+    );
+  }
+  const tests = [];
+  for (const [field, held] of Object.entries(where)) {
+    const path = [item, field];
+    if (!isPlainObject(held)) {
+      tests.push({ root: "event", path, operator: "eq", value: held });
+      continue;
+    }
+    for (const [operator, value] of Object.entries(held)) {
+      if (operator === "becomes") {
+        tests.push({ root: "event", path, operator: "becomes", value });
+      } else if (FIELD_OPERATORS.includes(operator)) {
+        tests.push({
+          root: "event",
+          path,
+          operator,
+          value
+        });
+      } else {
+        throw new TypeError(`where.${field}: ${operator} is not becomes or a list grammar operator`);
+      }
+    }
+  }
+  const [only] = tests;
+  return tests.length === 1 && only !== void 0 ? only : { and: tests };
+}
+chunkL6DXCKVQ_cjs.__name(whereOf, "whereOf");
+var ITEM = /* @__PURE__ */ Symbol("relyio.automation.item");
+var ITEM_REF = /* @__PURE__ */ Symbol("relyio.automation.item-ref");
+function uidOf(uid, at) {
+  const value = valueOf(uid, at);
+  if (value.kind === "ref") return value;
+  if (value.kind === "literal" && typeof value.value === "string" && value.value !== "") {
+    return value;
+  }
+  throw new TypeError(
+    `${at} is a uid: a reference to one (event.record._metadata.id, a reference field, an earlier step's output) or a uid written out`
+  );
+}
+chunkL6DXCKVQ_cjs.__name(uidOf, "uidOf");
+function itemRefOf(type, uid, at) {
+  const held = uidOf(uid, at);
+  return type.kind === "record" ? { kind: "record", recordType: type.recordType, uid: held } : { kind: "entry", contentType: type.contentType, uid: held };
+}
+chunkL6DXCKVQ_cjs.__name(itemRefOf, "itemRefOf");
+var RECORD_ACTIONS = [
+  "created",
+  "updated",
+  "deleted",
+  "expired"
+];
+var ENTRY_ACTIONS = [
+  "created",
+  "updated",
+  "published",
+  "unpublished",
+  "deleted",
+  "archived",
+  "restored"
+];
+function triggersByType(make) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, key) {
+      if (typeof key !== "string" || key === "then") return void 0;
+      return make(key);
+    }
+  });
+}
+chunkL6DXCKVQ_cjs.__name(triggersByType, "triggersByType");
+function itemHandleOf(type) {
+  const name = type.kind === "record" ? `records.${type.recordType}` : `entries.${type.contentType}`;
+  return {
+    [ITEM]: type,
+    ref: /* @__PURE__ */ chunkL6DXCKVQ_cjs.__name((uid) => ({
+      [ITEM_REF]: itemRefOf(type, uid, `${name}.ref`)
+    }), "ref")
+  };
+}
+chunkL6DXCKVQ_cjs.__name(itemHandleOf, "itemHandleOf");
+var records = triggersByType((recordType) => ({
+  ...itemHandleOf({ kind: "record", recordType }),
+  ...Object.fromEntries(
+    RECORD_ACTIONS.map((action) => [
+      action,
+      (options) => ({
+        trigger: {
+          kind: "record",
+          recordType,
+          action,
+          ...options?.where === void 0 ? {} : { where: whereOf(options.where, "record") }
+        }
+      })
+    ])
+  )
+}));
+var entries = triggersByType((contentType) => ({
+  ...itemHandleOf({ kind: "entry", contentType }),
+  ...Object.fromEntries(
+    ENTRY_ACTIONS.map((action) => [
+      action,
+      (options) => ({
+        trigger: {
+          kind: "entry",
+          contentType,
+          action,
+          ...options?.where === void 0 ? {} : { where: whereOf(options.where, "entry") }
+        }
+      })
+    ])
+  )
+}));
+var anyEntry = Object.fromEntries(
+  ENTRY_ACTIONS.map((action) => [
+    action,
+    (options) => {
+      const where = options?.where;
+      return {
+        trigger: {
+          kind: "anyEntry",
+          action,
+          ...where === void 0 ? {} : { where: where(refAt("event", [], false)) }
+        }
+      };
+    }
+  ])
+);
+var schedule = {
+  cron(cron, options) {
+    return { trigger: { kind: "schedule", cron, timezone: options.timezone } };
+  }
+};
+var RUN_FAILED_PATHS = {
+  automation: ["automation"],
+  step: ["step", "name"],
+  code: ["error", "code"]
+};
+function runFailedWhereOf(where) {
+  if (typeof where === "function") {
+    return where(refAt("event", [], false));
+  }
+  if (!isPlainObject(where)) {
+    throw new TypeError(
+      "A failed run\u2019s where is { automation, step, code }, or a function of the event"
+    );
+  }
+  const tests = [];
+  for (const [name, held] of Object.entries(where)) {
+    if (!Object.keys(RUN_FAILED_PATHS).includes(name)) {
+      throw new TypeError(`where.${name}: a failed run is filtered on automation, step and code`);
+    }
+    const path = RUN_FAILED_PATHS[name];
+    if (!isPlainObject(held)) {
+      tests.push({ root: "event", path, operator: "eq", value: held });
+      continue;
+    }
+    for (const [operator, value] of Object.entries(held)) {
+      if (!FIELD_OPERATORS.includes(operator)) {
+        throw new TypeError(`where.${name}: ${operator} is not a list grammar operator`);
+      }
+      tests.push({
+        root: "event",
+        path,
+        operator,
+        value
+      });
+    }
+  }
+  const [only] = tests;
+  return tests.length === 1 && only !== void 0 ? only : { and: tests };
+}
+chunkL6DXCKVQ_cjs.__name(runFailedWhereOf, "runFailedWhereOf");
+var automations = {
+  runFailed(options) {
+    return {
+      trigger: {
+        kind: "runFailed",
+        ...options?.where === void 0 ? {} : { where: runFailedWhereOf(options.where) }
+      }
+    };
+  }
+};
+function extensionTrigger(extension, trigger, options) {
+  const where = options?.where;
+  return {
+    trigger: {
+      kind: "extension",
+      extension,
+      trigger,
+      ...where === void 0 ? {} : { where: where(refAt("event", [], false)) }
+    }
+  };
+}
+chunkL6DXCKVQ_cjs.__name(extensionTrigger, "extensionTrigger");
+var on = { records, entries, anyEntry, schedule, automations };
+var STEP = /* @__PURE__ */ Symbol("relyio.automation.step");
+var ASK_DEFAULT_ROLES = ["editor", "admin"];
+var ASK_DEFAULT_TIMEOUT = "7d";
+var APPROVE_CHOICES = ["approve", "reject"];
+function handle(draft, output) {
+  const step = { name: draft.name, [STEP]: draft };
+  if (!output) return step;
+  const withOutput = {
+    ...step,
+    output: refAt(draft.name, ["output"], false)
+  };
+  return withOutput;
+}
+chunkL6DXCKVQ_cjs.__name(handle, "handle");
+function draftsOf(steps, at) {
+  return steps.map((step, index) => {
+    const draft = step[STEP];
+    if (draft === void 0) {
+      throw new TypeError(`${at}[${index}] is not a step: build one with step.fn, step.if, \u2026`);
+    }
+    return draft;
+  });
+}
+chunkL6DXCKVQ_cjs.__name(draftsOf, "draftsOf");
+var STEP_BUILDER = {
+  fn(name, fn, input) {
+    return handle(
+      { kind: "function", name, function: fn, input: inputOf(input, `${name}.input`) },
+      true
+    );
+  },
+  agent(name, config) {
+    const { propose } = config;
+    return handle(
+      {
+        kind: "agent",
+        name,
+        ...config.agent === void 0 ? {} : { agent: config.agent },
+        instructions: valueOf(config.instructions, `${name}.instructions`),
+        context: inputOf(config.context ?? {}, `${name}.context`),
+        output: chunkZAMAR3X2_cjs.compileKeyedMembers(config.output),
+        ...propose === void 0 ? {} : {
+          propose: propose.map(
+            (type, index) => proposeTargetOf(type, `${name}.propose[${index}]`)
+          )
+        }
+      },
+      true
+    );
+  },
+  action(name, action, input) {
+    return handle(
+      {
+        kind: "action",
+        name,
+        extension: action.extension,
+        action: action.action,
+        input: inputOf(input, `${name}.input`)
+      },
+      true
+    );
+  },
+  lookup(name, type, uidOrOptions, options) {
+    const held = type ?? {};
+    let item;
+    let given;
+    if (held[ITEM_REF] !== void 0) {
+      item = held[ITEM_REF];
+      given = uidOrOptions;
+    } else if (held[ITEM] !== void 0) {
+      item = itemRefOf(held[ITEM], uidOrOptions, `${name}.uid`);
+      given = options;
+    } else {
+      throw new TypeError(
+        `${name} looks up a Record or entry type \u2014 records.<type>, entries.<type> \u2014 or one item, <type>.ref(uid)`
+      );
+    }
+    const { state } = given ?? {};
+    if (item.kind === "record") {
+      if (state !== void 0) {
+        throw new TypeError(`${name}: a Record has no draft; state is an entry Look-up's alone`);
+      }
+      return handle({ kind: "lookup", name, item }, true);
+    }
+    return handle({ kind: "lookup", name, item, state: state ?? "published" }, true);
+  },
+  if(name, condition, branches) {
+    return handle(
+      {
+        kind: "if",
+        name,
+        condition,
+        then: draftsOf(branches.then ?? [], `${name}.then`),
+        else: draftsOf(branches.else ?? [], `${name}.else`)
+      },
+      false
+    );
+  },
+  wait(name, duration) {
+    return handle({ kind: "wait", name, duration }, false);
+  },
+  ask(name, config) {
+    const approving = "approve" in config;
+    const approve = approving ? valueOf(config.approve, `${name}.approve`) : void 0;
+    if (approve !== void 0 && approve.kind !== "ref") {
+      throw new TypeError(`${name}.approve names an Agent step's proposal: <step>.output.proposal`);
+    }
+    return handle(
+      {
+        kind: "ask",
+        name,
+        to: [...config.to ?? ASK_DEFAULT_ROLES],
+        question: valueOf(config.question, `${name}.question`),
+        choices: approving ? [...APPROVE_CHOICES] : [...config.choices],
+        timeout: config.timeout ?? ASK_DEFAULT_TIMEOUT,
+        ...config.onTimeout === void 0 ? {} : { onTimeout: config.onTimeout },
+        ...config.sample === void 0 ? {} : { sample: config.sample },
+        ...approve === void 0 ? {} : { approve }
+      },
+      true
+    );
+  }
+};
+function proposeTargetOf(type, at) {
+  const held = type ?? {};
+  const named = held[ITEM];
+  if (named === void 0) {
+    throw new TypeError(`${at} is a Record or content type: records.<type>, entries.<type>`);
+  }
+  return named.kind === "record" ? { kind: "record", recordType: named.recordType } : { kind: "entry", contentType: named.contentType };
+}
+chunkL6DXCKVQ_cjs.__name(proposeTargetOf, "proposeTargetOf");
+function defineAutomation(config) {
+  const event = refAt("event", [], false);
+  const steps = config.steps({ event, step: STEP_BUILDER });
+  return {
+    _tag: "automation",
+    ...config.description === void 0 ? {} : { description: config.description },
+    on: config.on.trigger,
+    ...config.about === void 0 ? {} : { about: aboutOf(config.about({ event })) },
+    steps: draftsOf(steps, "steps")
+  };
+}
+chunkL6DXCKVQ_cjs.__name(defineAutomation, "defineAutomation");
+function aboutOf(handle2) {
+  const item = handle2?.[ITEM_REF];
+  if (item === void 0) {
+    throw new TypeError(
+      "about is one Record or entry: return records.<type>.ref(uid) or entries.<type>.ref(uid)"
+    );
+  }
+  return item;
+}
+chunkL6DXCKVQ_cjs.__name(aboutOf, "aboutOf");
+function isAutomationFile(value) {
+  return typeof value === "object" && value !== null && value._tag === "automation" && Array.isArray(value.steps) && typeof value.on === "object";
+}
+chunkL6DXCKVQ_cjs.__name(isAutomationFile, "isAutomationFile");
+function resolveAutomation(file, nameOf) {
+  const resolve = /* @__PURE__ */ chunkL6DXCKVQ_cjs.__name((steps) => steps.map((step) => {
+    switch (step.kind) {
+      case "function": {
+        const name = nameOf(step.function);
+        if (name === void 0) {
+          throw new Error(
+            `Step ${step.name} takes a Function no file under relyio/functions/ exports: import the Function file's default export`
+          );
+        }
+        return { kind: "function", name: step.name, function: name, input: step.input };
+      }
+      case "if": {
+        return { ...step, then: resolve(step.then), else: resolve(step.else) };
+      }
+      case "agent":
+      case "action":
+      case "lookup":
+      case "wait":
+      case "ask": {
+        return step;
+      }
+      default: {
+        const unhandled = step;
+        throw new Error(`No step kind ${JSON.stringify(unhandled)}`);
+      }
+    }
+  }), "resolve");
+  return {
+    ...file.description === void 0 ? {} : { description: file.description },
+    on: file.on,
+    ...file.about === void 0 ? {} : { about: file.about },
+    steps: resolve(file.steps)
+  };
+}
+chunkL6DXCKVQ_cjs.__name(resolveAutomation, "resolveAutomation");
+
+exports.and = and;
+exports.anyEntry = anyEntry;
+exports.automations = automations;
+exports.defineAutomation = defineAutomation;
+exports.entries = entries;
+exports.extensionTrigger = extensionTrigger;
+exports.isAutomationFile = isAutomationFile;
+exports.not = not;
+exports.on = on;
+exports.or = or;
+exports.records = records;
+exports.resolveAutomation = resolveAutomation;
+exports.schedule = schedule;
+exports.tpl = tpl;
+//# sourceMappingURL=chunk-LSI26ZN2.cjs.map
+//# sourceMappingURL=chunk-LSI26ZN2.cjs.map