@kizenapps/engine 0.0.1-b1f3597

package/dist/chunk-NXLAROEM.js

@@ -0,0 +1,730 @@
+import { cleanConfig } from './chunk-VYBEGZLN.js';
+import { Communicate } from './chunk-GGGXYD3K.js';
+import { RESPONSES, ACTIONS, ThirdPartyScript } from './chunk-P7GQBCEH.js';
+
+// src/contexts/BaseWorkerContext.ts
+var buildErrorResponse = async (result) => {
+  let errorJSON = null;
+  try {
+    errorJSON = await result.json();
+  } catch {
+  }
+  const error = {
+    status: result.status,
+    statusText: result.statusText,
+    body: errorJSON
+  };
+  return error;
+};
+var convertToSelfInvokingFunction = (fn, variable, args = {}, prepend = "") => {
+  const functionString = fn.toString();
+  const innner = `(${functionString})({ state: {{${variable}}}, args: ${JSON.stringify(args)}, utils: __kizen_utils })`;
+  const full = `(function() { ${prepend}
+return ${innner}; })()`;
+  return full;
+};
+var BaseWorkerContext = class {
+  user;
+  teamMember;
+  business;
+  clientObject;
+  appPath;
+  dataCache = /* @__PURE__ */ new Map();
+  queryOptions = {};
+  api;
+  postFormData;
+  executionTimer = 0;
+  setupExecutions = 0;
+  cleanupExecutions = 0;
+  isDebug = false;
+  scriptBody;
+  internalState = { indicator: "none" /* NONE */ };
+  console = console;
+  instance;
+  breakOnException = false;
+  args;
+  communicate;
+  shouldPreserve = false;
+  uploadFileHandler;
+  internalSessionData;
+  pluginComponentId;
+  installThirdPartyScriptHandler;
+  promptHandler;
+  dynamicPromptHandler;
+  refreshEntityHandler;
+  openCreateRecordHandler;
+  openCreateRelatedRecordHandler;
+  runnerType;
+  pluginApiName;
+  tempPromptState = {};
+  partialLocation;
+  constructor({
+    user,
+    teamMember,
+    business,
+    clientObject,
+    appPath,
+    isDebug,
+    kizenRequest,
+    postFormData,
+    scriptBody,
+    instance,
+    args,
+    uploadFile,
+    sessionData,
+    pluginComponentId,
+    installThirdPartyScript,
+    prompt,
+    refreshEntity,
+    openCreateRecord,
+    openCreateRelatedRecord,
+    pluginApiName,
+    dynamicPrompt,
+    location
+  }) {
+    this.user = user;
+    this.teamMember = teamMember;
+    this.business = business;
+    this.clientObject = clientObject;
+    this.partialLocation = location;
+    this.appPath = appPath;
+    this.isDebug = isDebug ?? false;
+    this.api = {
+      get: kizenRequest("get"),
+      post: kizenRequest("post"),
+      put: kizenRequest("put"),
+      delete: kizenRequest("delete"),
+      patch: kizenRequest("patch")
+    };
+    this.postFormData = postFormData;
+    this.scriptBody = scriptBody;
+    this.instance = instance;
+    this.communicate = new Communicate(instance);
+    this.uploadFileHandler = uploadFile;
+    this.internalSessionData = sessionData ?? {};
+    this.pluginComponentId = pluginComponentId;
+    this.installThirdPartyScriptHandler = installThirdPartyScript;
+    this.promptHandler = prompt;
+    this.refreshEntityHandler = refreshEntity;
+    this.openCreateRecordHandler = openCreateRecord;
+    this.openCreateRelatedRecordHandler = openCreateRelatedRecord;
+    this.runnerType = "base";
+    this.pluginApiName = pluginApiName;
+    this.dynamicPromptHandler = dynamicPrompt;
+    try {
+      this.args = JSON.parse(args ?? "{}");
+    } catch {
+      this.args = {};
+    }
+  }
+  onError(error) {
+    if (this.breakOnException) {
+      debugger;
+    }
+    this.instance.postMessage(
+      JSON.stringify({
+        action: RESPONSES.ERROR,
+        error: error?.message
+      })
+    );
+  }
+  set debug(value) {
+    this.isDebug = value;
+    this.breakOnException = value;
+  }
+  set preserve(value) {
+    this.shouldPreserve = value;
+  }
+  get preserve() {
+    return this.shouldPreserve;
+  }
+  parseDate(date) {
+    return date.split("-");
+  }
+  parsePhone(phone) {
+    return phone.replace(/\+/g, "");
+  }
+  openWindow(url, target = "_blank") {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.OPEN_WINDOW,
+        url,
+        target,
+        features: "noopener noreferrer"
+      })
+    );
+  }
+  authorize(serviceName, config = {}) {
+    if (!serviceName) {
+      throw new Error("Service name is required to authorize");
+    }
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.AUTHORIZE,
+        serviceName,
+        config: {
+          successRedirectPath: config.successRedirectPath ?? `/marketplace/${this.pluginApiName}/auth`,
+          errorRedirectPath: config.errorRedirectPath ?? `/marketplace/${this.pluginApiName}/auth`
+        }
+      })
+    );
+  }
+  getServiceUrl(serviceName, path) {
+    if (!serviceName) {
+      throw new Error("Service name is required to get a service url");
+    }
+    const base = `/external-integrations/proxy/${this.pluginApiName}/${serviceName}`;
+    if (path.startsWith("/")) {
+      return `${base}${path}`;
+    }
+    return `${base}/${path}`;
+  }
+  get currentBusiness() {
+    return this.business;
+  }
+  get applicationPath() {
+    return this.appPath;
+  }
+  get currentUser() {
+    return {
+      profile: {
+        id: this.teamMember?.id ?? "",
+        full_name: this.teamMember?.full_name ?? "",
+        first_name: this.teamMember?.first_name ?? "",
+        last_name: this.teamMember?.last_name ?? "",
+        email: this.teamMember?.email ?? "",
+        phone: this.teamMember?.phone ?? "",
+        created: this.teamMember?.created ?? "",
+        crm_client_id: this.user?.crm_client_id ?? ""
+      }
+    };
+  }
+  get sessionData() {
+    return this.internalSessionData;
+  }
+  get config() {
+    const hasCustomConfig = Boolean(this.args.__kizen_clean_config);
+    if (!hasCustomConfig) {
+      return {};
+    }
+    const manager = new Proxy(this.args.__kizen_clean_config ?? {}, {
+      get: (target, name) => {
+        if (Reflect.has(target, name)) {
+          return Reflect.get(target, name);
+        }
+        return void 0;
+      }
+    });
+    return manager;
+  }
+  get location() {
+    return new Proxy(this.partialLocation, {
+      get: (target, name) => {
+        if (name === "toJSON") {
+          return () => {
+            return this.partialLocation;
+          };
+        }
+        if (Reflect.has(target, name)) {
+          return Reflect.get(target, name);
+        }
+        throw new Error(
+          `Property ${String(name)} is not available on location object for plugin apps`
+        );
+      }
+    });
+  }
+  get userConfig() {
+    const customConfig = this.args.__kizen_user_config?.__kizen_clean_config;
+    if (!customConfig) {
+      return {};
+    }
+    const manager = new Proxy(customConfig, {
+      get: (target, name) => {
+        if (Reflect.has(target, name)) {
+          return Reflect.get(target, name);
+        }
+        return void 0;
+      }
+    });
+    return manager;
+  }
+  setSessionData(update) {
+    if (typeof update !== "object") {
+      throw new Error(`Invalid session update with type ${typeof update}`);
+    }
+    if (Array.isArray(update)) {
+      throw new Error(`Invalid session update with type array`);
+    }
+    this.internalSessionData = {
+      ...this.internalSessionData,
+      ...update
+    };
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.UPDATE_SESSION_DATA,
+        update
+      })
+    );
+  }
+  async get(url, options) {
+    try {
+      if (this.isRelativeUrl(url)) {
+        const cachedResult = this.dataCache.get(url);
+        if (cachedResult && !options?.ignoreCache) {
+          if (options?.returnErrors) {
+            return [cachedResult.data, null];
+          }
+          return cachedResult.data;
+        }
+        const { data } = await this.api.get(url, {
+          ...this.queryOptions,
+          headers: this.buildHeaders(options?.headers)
+        });
+        this.dataCache.set(url, { ts: Date.now(), data });
+        if (options?.returnErrors) {
+          return [data, null];
+        }
+        return data;
+      } else {
+        const res = await fetch(url, {
+          method: "GET",
+          headers: new Headers(options?.headers),
+          credentials: options?.credentials ?? "same-origin"
+        });
+        if (!res.ok) {
+          const err = await buildErrorResponse(res);
+          throw err;
+        }
+        const json = await res.json();
+        if (options?.returnErrors) {
+          return [json, null];
+        }
+        return json;
+      }
+    } catch (ex) {
+      if (options?.returnErrors) {
+        return [null, ex];
+      } else {
+        this.onError(ex);
+      }
+    }
+  }
+  async getWithErrors(url, options) {
+    return this.get(url, {
+      ...options,
+      returnErrors: true
+    });
+  }
+  async getUserConfig() {
+    if (!this.args.pluginId || !this.pluginComponentId) {
+      throw new Error(
+        "User config is not available for scripts not associated to a plugin or plugin component"
+      );
+    }
+    const configResult = await this.get(`/employee/mine/configs/plugins/${this.args.pluginId}`, {
+      ignoreCache: true
+    });
+    return configResult.config?.[this.pluginComponentId] ?? {};
+  }
+  async setUserConfig(config) {
+    if (!this.args.pluginId || !this.pluginComponentId) {
+      throw new Error(
+        "User config is not available for scripts not associated to a plugin or plugin component"
+      );
+    }
+    const oldConfig = await this.get(`/employee/mine/configs/plugins/${this.args.pluginId}`, {
+      ignoreCache: true
+    });
+    const mutationResult = await this.post(`/employee/mine/configs/plugins/${this.args.pluginId}`, {
+      config: {
+        ...oldConfig?.config,
+        [this.pluginComponentId]: {
+          ...oldConfig?.config?.[this.pluginComponentId],
+          ...config
+        }
+      }
+    });
+    return mutationResult;
+  }
+  async patch(url, body, options) {
+    try {
+      if (this.isRelativeUrl(url)) {
+        const { data } = await this.api.patch(url, body, {
+          ...this.queryOptions,
+          headers: options?.headers
+        });
+        if (options?.returnErrors) {
+          return [data, null];
+        }
+        return data;
+      } else {
+        const res = await fetch(url, {
+          method: "PATCH",
+          body: body ? JSON.stringify(body) : null,
+          headers: new Headers(options?.headers),
+          credentials: options?.credentials ?? "same-origin"
+        });
+        if (!res.ok) {
+          const err = await buildErrorResponse(res);
+          throw err;
+        }
+        const json = await res.json();
+        if (options?.returnErrors) {
+          return [json, null];
+        }
+        return json;
+      }
+    } catch (ex) {
+      if (options?.returnErrors) {
+        return [null, ex];
+      } else {
+        this.onError(ex);
+      }
+    }
+  }
+  async patchWithErrors(url, body, options) {
+    return this.patch(url, body, {
+      ...options,
+      returnErrors: true
+    });
+  }
+  async post(url, body, options) {
+    try {
+      if (this.isRelativeUrl(url)) {
+        const { data } = await this.api.post(url, body, {
+          ...this.queryOptions,
+          headers: this.buildHeaders(options?.headers)
+        });
+        if (options?.returnErrors) {
+          return [data, null];
+        }
+        return data;
+      } else {
+        const res = await fetch(url, {
+          method: "POST",
+          body: body ? JSON.stringify(body) : null,
+          headers: new Headers(options?.headers),
+          credentials: options?.credentials ?? "same-origin"
+        });
+        if (!res.ok) {
+          const err = await buildErrorResponse(res);
+          throw err;
+        }
+        const json = await res.json();
+        if (options?.returnErrors) {
+          return [json, null];
+        }
+        return json;
+      }
+    } catch (ex) {
+      if (options?.returnErrors) {
+        return [null, ex];
+      } else {
+        this.onError(ex);
+      }
+    }
+  }
+  async postWithErrors(url, body, options) {
+    return this.post(url, body, {
+      ...options,
+      returnErrors: true
+    });
+  }
+  async delete(url, options) {
+    try {
+      if (this.isRelativeUrl(url)) {
+        const { data } = await this.api.delete(url, {
+          ...this.queryOptions,
+          headers: this.buildHeaders(options?.headers)
+        });
+        if (options?.returnErrors) {
+          return [data, null];
+        }
+        return data;
+      } else {
+        const res = await fetch(url, {
+          method: "DELETE",
+          headers: new Headers(options?.headers),
+          credentials: options?.credentials ?? "same-origin"
+        });
+        if (!res.ok) {
+          const err = await buildErrorResponse(res);
+          throw err;
+        }
+        let json = null;
+        if (res.status !== 204) {
+          json = await res.json();
+        }
+        if (options?.returnErrors) {
+          return [json, null];
+        }
+        return json;
+      }
+    } catch (ex) {
+      if (options?.returnErrors) {
+        return [null, ex];
+      } else {
+        this.onError(ex);
+      }
+    }
+  }
+  async deleteWithErrors(url, options) {
+    return this.delete(url, {
+      ...options,
+      returnErrors: true
+    });
+  }
+  async openCreateRecordModal(objectId) {
+    return this.openCreateRecordHandler(objectId);
+  }
+  async openCreateRelatedRecordModal(objectId, relatedEntityId) {
+    return this.openCreateRelatedRecordHandler(objectId, relatedEntityId);
+  }
+  showToast(message, toastOptions) {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.SHOW_TOAST,
+        message,
+        toastOptions
+      })
+    );
+  }
+  clearToasts() {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.CLEAR_TOASTS
+      })
+    );
+  }
+  outputUI(markup) {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.UI_OUTPUT,
+        markup
+      })
+    );
+  }
+  prompt(config) {
+    return this.promptHandler(config);
+  }
+  async dynamicPrompt(_config) {
+    const replacementVar = "__kizen_state";
+    let prepend = "const __kizen_utils = {};\n";
+    if (_config.registerUtils) {
+      const utils = Object.keys(_config.registerUtils);
+      prepend += utils.map((u) => {
+        const body = _config.registerUtils?.[u];
+        if (typeof body !== "function") {
+          throw new Error(`Registered util ${u} is not a function, got ${typeof body}`);
+        }
+        return `__kizen_utils["${u}"] = (${body.toString()});`;
+      }).join("\n");
+    }
+    const configContentResult = _config.content?.map((f) => {
+      let optionMapper = "";
+      if ("optionMapper" in f) {
+        optionMapper = convertToSelfInvokingFunction(
+          f.optionMapper,
+          replacementVar,
+          f.args,
+          prepend
+        );
+      }
+      let getFetchUrl = "";
+      if ("getFetchUrl" in f) {
+        getFetchUrl = convertToSelfInvokingFunction(f.getFetchUrl, replacementVar, f.args, prepend);
+      }
+      let getHeaders = "";
+      if ("getHeaders" in f) {
+        getHeaders = convertToSelfInvokingFunction(f.getHeaders, replacementVar, f.args, prepend);
+      }
+      let getBody = "";
+      if ("getBody" in f) {
+        getBody = convertToSelfInvokingFunction(f.getBody, replacementVar, f.args, prepend);
+      }
+      return {
+        ...f,
+        optionMapper,
+        getFetchUrl,
+        getHeaders,
+        getBody
+      };
+    });
+    const config = {
+      ..._config,
+      content: configContentResult
+    };
+    const setupAssistantConfig = {
+      fields: config.content
+    };
+    const result = await this.dynamicPromptHandler(config);
+    const cleanConfigValue = cleanConfig(setupAssistantConfig, result.values);
+    return {
+      ...result,
+      values: cleanConfigValue
+    };
+  }
+  outputIframe(url, allow, sandbox) {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.IFRAME_OUTPUT,
+        url,
+        allow,
+        sandbox,
+        preserve: this.preserve
+      })
+    );
+  }
+  getBase64EncodedBlob(data) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.readAsDataURL(data);
+      reader.onload = () => {
+        resolve(reader.result);
+      };
+      reader.onerror = (error) => {
+        reject(error);
+      };
+    });
+  }
+  async uploadFile(data, fileName, isPublic = false) {
+    const encoded = await this.getBase64EncodedBlob(data);
+    const res = await this.uploadFileHandler({
+      file: encoded,
+      fileName: fileName ?? "file_" + String(Date.now()),
+      isPublic
+    });
+    return res;
+  }
+  afterSetup() {
+  }
+  __setup() {
+    if (this.setupExecutions !== 0) {
+      throw new Error(
+        "Setup must be called exactly once, and should never be called by a script directly."
+      );
+    }
+    if (this.cleanupExecutions !== 0) {
+      throw new Error("Setup was called after cleanup");
+    }
+    if (this.isDebug) {
+      this.console.log(`Running script:
+
+${this.scriptBody}`);
+    }
+    this.setupExecutions++;
+    this.executionTimer = performance.now();
+    this.afterSetup();
+  }
+  __cleanup(result) {
+    if (this.cleanupExecutions !== 0) {
+      throw new Error(
+        "Cleanup must be called exactly once, and should never be called by a script directly."
+      );
+    }
+    if (this.setupExecutions !== 1) {
+      throw new Error("Cleanup was called before setup");
+    }
+    this.cleanupExecutions++;
+    this.setIndicator("none" /* NONE */);
+    const end = performance.now();
+    if (this.isDebug) {
+      this.console.log(`Script execution took ${String(end - this.executionTimer)}ms`);
+    }
+    this.done(this.preserve, result);
+  }
+  setIndicator(indicator = "none" /* NONE */) {
+    this.internalState.indicator = indicator;
+    this.setState({ indicator });
+  }
+  wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  done(preserve, result) {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.DONE,
+        result,
+        preserve
+      })
+    );
+  }
+  setState(state) {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.SETSTATE,
+        state
+      })
+    );
+  }
+  isRelativeUrl(url) {
+    return url.startsWith("/");
+  }
+  buildHeaders(headers = {}) {
+    return {
+      ...headers,
+      "X-Request-Type": "kizen-ui-scripting-api"
+    };
+  }
+  refreshTimelineForId(id) {
+    if (id) {
+      this.instance.postMessage(
+        JSON.stringify({
+          action: ACTIONS.REFRESH_TIMELINE,
+          entityId: id
+        })
+      );
+    }
+  }
+  refreshEntityForId(id) {
+    if (id) {
+      return this.refreshEntityHandler(id);
+    }
+  }
+  async installThirdPartyScript(scriptUrl) {
+    try {
+      const result = await this.installThirdPartyScriptHandler(scriptUrl, this.args);
+      const manager = new ThirdPartyScript(this.instance, result.url);
+      return manager;
+    } catch {
+      this.onError(new Error(`Third party script ${scriptUrl} could not be installed.`));
+    }
+  }
+  releaseBlockingScript() {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.RELEASE_BLOCKING_SCRIPT
+      })
+    );
+  }
+  copyToClipboard(text) {
+    this.instance.postMessage(
+      JSON.stringify({
+        action: ACTIONS.COPY_TO_CLIPBOARD,
+        text
+      })
+    );
+  }
+  createDateObject(dateString) {
+    if (typeof dateString !== "string") {
+      throw new Error(`Invalid date string ${String(dateString)}`);
+    }
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(dateString)) {
+      throw new Error(`Date string ${dateString} is not in the format YYYY-MM-DD`);
+    }
+    const parts = dateString.split("-").map((part) => parseInt(part, 10));
+    if (parts.length < 3) {
+      throw new Error(`Date string ${dateString} could not be parsed into valid date parts`);
+    }
+    const dateObj = new Date(parts[0], parts[1] - 1, parts[2]);
+    return dateObj;
+  }
+  formatDateForResponse(date) {
+    return date.getTime();
+  }
+};
+
+export { BaseWorkerContext };
+//# sourceMappingURL=chunk-NXLAROEM.js.map
+//# sourceMappingURL=chunk-NXLAROEM.js.map