instill-sdk 0.0.1

package/dist/chunk-4VWYH26Q.mjs

@@ -0,0 +1,145 @@
+import {
+  deployUserModelAction,
+  undeployUserModelAction
+} from "./chunk-D5OKZ665.mjs";
+import {
+  createUserModelMutation,
+  deleteUserModelMutation,
+  updateModelMutation
+} from "./chunk-QZOKJQTL.mjs";
+import {
+  getModelDefinitionQuery,
+  getUserModelQuery,
+  getUserModelReadmeQuery,
+  listModelDefinitionsQuery,
+  listModelsQuery,
+  listUserModelsQuery,
+  watchUserModel
+} from "./chunk-KHFNAMT4.mjs";
+
+// src/model/ModelClient.ts
+import axios from "axios";
+var ModelClient = class {
+  axiosInstance;
+  constructor(baseUrl, appVersion, apiToken) {
+    let URL = `${baseUrl}/model/${appVersion}`;
+    this.axiosInstance = axios.create({
+      baseURL: URL,
+      headers: {
+        Authorization: `Bearer ${apiToken}`
+      }
+    });
+  }
+  /* -------------------------------------------------------------------------
+   * Model Queries
+   * -----------------------------------------------------------------------*/
+  async getModelDefinitionQuery({
+    modelDefinitionName
+  }) {
+    return getModelDefinitionQuery({
+      axiosInstance: this.axiosInstance,
+      modelDefinitionName
+    });
+  }
+  async listModelDefinitionsQuery({
+    pageSize,
+    nextPageToken
+  }) {
+    return listModelDefinitionsQuery({
+      axiosInstance: this.axiosInstance,
+      pageSize,
+      nextPageToken
+    });
+  }
+  /* -------------------------------------------------------------------------
+   * Model
+   * -----------------------------------------------------------------------*/
+  async getUserModelQuery({ modelName }) {
+    return getUserModelQuery({
+      axiosInstance: this.axiosInstance,
+      modelName
+    });
+  }
+  async listModelsQuery({
+    pageSize,
+    nextPageToken
+  }) {
+    return listModelsQuery({
+      axiosInstance: this.axiosInstance,
+      pageSize,
+      nextPageToken
+    });
+  }
+  async listUserModelsQuery({
+    userName,
+    pageSize,
+    nextPageToken
+  }) {
+    return listUserModelsQuery({
+      axiosInstance: this.axiosInstance,
+      userName,
+      pageSize,
+      nextPageToken
+    });
+  }
+  async getUserModelReadmeQuery({ modelName }) {
+    return getUserModelReadmeQuery({
+      axiosInstance: this.axiosInstance,
+      modelName
+    });
+  }
+  /* -------------------------------------------------------------------------
+   * Watch Model State
+   * -----------------------------------------------------------------------*/
+  async watchUserModel({ modelName }) {
+    return watchUserModel({
+      axiosInstance: this.axiosInstance,
+      modelName
+    });
+  }
+  /* -------------------------------------------------------------------------
+   * Model Mutation
+   * -----------------------------------------------------------------------*/
+  async createUserModelMutation({
+    userName,
+    payload
+  }) {
+    return createUserModelMutation({
+      axiosInstance: this.axiosInstance,
+      userName,
+      payload
+    });
+  }
+  async updateModelMutation({ payload }) {
+    return updateModelMutation({
+      axiosInstance: this.axiosInstance,
+      payload
+    });
+  }
+  async deleteUserModelMutation({ modelName }) {
+    return deleteUserModelMutation({
+      axiosInstance: this.axiosInstance,
+      modelName
+    });
+  }
+  /* -------------------------------------------------------------------------
+   * Model Action
+   * -----------------------------------------------------------------------*/
+  async deployUserModelAction({ modelName }) {
+    return deployUserModelAction({
+      axiosInstance: this.axiosInstance,
+      modelName
+    });
+  }
+  async undeployUserModelAction({ modelName }) {
+    return undeployUserModelAction({
+      axiosInstance: this.axiosInstance,
+      modelName
+    });
+  }
+};
+var ModelClient_default = ModelClient;
+
+export {
+  ModelClient_default
+};

package/dist/chunk-6M57XUNI.mjs

@@ -0,0 +1,64 @@
+// src/connector/mutation.ts
+async function createUserConnectorResourceMutation({
+  axiosInstance,
+  userName,
+  payload
+}) {
+  try {
+    const res = await axiosInstance.post(
+      `${userName}/connector-resources`,
+      payload
+    );
+    return Promise.resolve(res.data.connector_resource);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function deleteUserConnectorResourceMutation({
+  axiosInstance,
+  connectorResourceName
+}) {
+  try {
+    await axiosInstance.delete(`/${connectorResourceName}`);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function updateUserConnectorResourceMutation({
+  axiosInstance,
+  payload
+}) {
+  try {
+    const res = await axiosInstance.patch(
+      `/${payload.connectorResourceName}`,
+      {
+        ...payload,
+        connectorResourceName: void 0
+      }
+    );
+    return Promise.resolve(res.data.connector_resource);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function renameUserConnectorResource({
+  axiosInstance,
+  payload
+}) {
+  try {
+    const { data } = await axiosInstance.post(
+      `/${payload.name}/rename`,
+      payload
+    );
+    return Promise.resolve(data.connector_resource);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+export {
+  createUserConnectorResourceMutation,
+  deleteUserConnectorResourceMutation,
+  updateUserConnectorResourceMutation,
+  renameUserConnectorResource
+};

package/dist/chunk-7KV3Y36U.mjs

@@ -0,0 +1,17 @@
+// src/helper/getInstillApiErrorMessage.tsx
+function getInstillApiErrorMessage(error) {
+  if (!error.response) {
+    return null;
+  }
+  if (!error.response.data.details && !error.response.data.message) {
+    return null;
+  }
+  if (error.response.data.details.length === 0) {
+    return error.response.data.message;
+  }
+  return JSON.stringify(error.response?.data.details, null, "	");
+}
+
+export {
+  getInstillApiErrorMessage
+};

package/dist/chunk-D5OKZ665.mjs

@@ -0,0 +1,32 @@
+// src/model/action.ts
+async function deployUserModelAction({
+  axiosInstance,
+  modelName
+}) {
+  try {
+    const { data } = await axiosInstance.post(
+      `/${modelName}/deploy`
+    );
+    return Promise.resolve(data.model_id);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function undeployUserModelAction({
+  axiosInstance,
+  modelName
+}) {
+  try {
+    const { data } = await axiosInstance.post(
+      `/${modelName}/undeploy`
+    );
+    return Promise.resolve(data.model_id);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+export {
+  deployUserModelAction,
+  undeployUserModelAction
+};

package/dist/chunk-DXEIDDIA.mjs

@@ -0,0 +1,32 @@
+import {
+  env
+} from "./chunk-RVRM4NPL.mjs";
+
+// src/helper/createClient.ts
+import axios from "axios";
+function createClient(apiToken, product, headers) {
+  let clientHeaders = {};
+  if (headers) {
+    clientHeaders = headers;
+  } else {
+    if (apiToken) {
+      clientHeaders = {
+        Authorization: `Bearer ${apiToken}`,
+        "CF-Access-Client-Id": env("CF_ACCESS_CLIENT_ID") ? env("CF_ACCESS_CLIENT_ID") : void 0,
+        "CF-Access-Client-Secret": env("CF_ACCESS_CLIENT_SECRET") ? env("CF_ACCESS_CLIENT_SECRET") : void 0
+      };
+    }
+  }
+  if (!process.env.API_GATEWAY_URL && !env("API_GATEWAY_URL")) {
+    throw new Error("API_GATEWAY_URL or API_GATEWAY_URL is not defined");
+  }
+  let baseURL = `${process.env.API_GATEWAY_URL ?? env("API_GATEWAY_URL")}/${product}/${env("API_VERSION")}`;
+  return axios.create({
+    baseURL,
+    headers: clientHeaders
+  });
+}
+
+export {
+  createClient
+};

package/dist/chunk-EBWGEVUX.mjs

@@ -0,0 +1,33 @@
+// src/helper/getQueryString.ts
+var getQueryString = ({
+  baseURL,
+  pageSize,
+  nextPageToken,
+  filter
+}) => {
+  let url = baseURL;
+  if (pageSize || nextPageToken || filter) {
+    if (baseURL.includes("?")) {
+      url += "&";
+    } else {
+      url += "?";
+    }
+  }
+  if (pageSize) {
+    url += `page_size=${pageSize}&`;
+  }
+  if (nextPageToken) {
+    url += `page_token=${nextPageToken}&`;
+  }
+  if (filter) {
+    url += `filter=${filter}&`;
+  }
+  if (url.endsWith("&")) {
+    url = url.slice(0, -1);
+  }
+  return url;
+};
+
+export {
+  getQueryString
+};

package/dist/chunk-ECC5KF6S.mjs

@@ -0,0 +1,150 @@
+import {
+  getQueryString
+} from "./chunk-EBWGEVUX.mjs";
+
+// src/pipeline/queries.ts
+async function listPipelinesQuery({
+  axiosInstance,
+  pageSize,
+  nextPageToken
+}) {
+  try {
+    const pipelines = [];
+    const queryString = getQueryString({
+      baseURL: "/pipelines?view=VIEW_FULL",
+      pageSize,
+      nextPageToken,
+      filter: null
+    });
+    const { data } = await axiosInstance.get(
+      queryString
+    );
+    pipelines.push(...data.pipelines);
+    if (data.next_page_token) {
+      pipelines.push(
+        ...await listPipelinesQuery({
+          axiosInstance,
+          pageSize,
+          nextPageToken: data.next_page_token
+        })
+      );
+    }
+    return Promise.resolve(pipelines);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function listUserPipelinesQuery({
+  axiosInstance,
+  pageSize,
+  nextPageToken,
+  userName
+}) {
+  try {
+    const pipelines = [];
+    const queryString = getQueryString({
+      baseURL: `${userName}/pipelines?view=VIEW_FULL`,
+      pageSize,
+      nextPageToken,
+      filter: null
+    });
+    const { data } = await axiosInstance.get(
+      queryString
+    );
+    pipelines.push(...data.pipelines);
+    if (data.next_page_token) {
+      pipelines.push(
+        ...await listUserPipelinesQuery({
+          axiosInstance,
+          pageSize,
+          nextPageToken: data.next_page_token,
+          userName
+        })
+      );
+    }
+    return Promise.resolve(pipelines);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function getUserPipelineQuery({
+  axiosInstance,
+  pipelineName
+}) {
+  try {
+    const { data } = await axiosInstance.get(
+      `/${pipelineName}?view=VIEW_FULL`
+    );
+    return Promise.resolve(data.pipeline);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function ListUserPipelineReleasesQuery({
+  axiosInstance,
+  pipelineName,
+  pageSize,
+  nextPageToken
+}) {
+  try {
+    const releases = [];
+    const queryString = getQueryString({
+      baseURL: `/${pipelineName}/releases?view=VIEW_FULL`,
+      pageSize,
+      nextPageToken,
+      filter: null
+    });
+    const { data } = await axiosInstance.get(
+      queryString
+    );
+    releases.push(...data.releases);
+    if (data.next_page_token) {
+      releases.push(
+        ...await ListUserPipelineReleasesQuery({
+          axiosInstance,
+          pipelineName,
+          pageSize,
+          nextPageToken: data.next_page_token
+        })
+      );
+    }
+    return Promise.resolve(releases);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function getUserPipelineReleaseQuery({
+  axiosInstance,
+  pipelineReleaseName
+}) {
+  try {
+    const { data } = await axiosInstance.get(
+      `/${pipelineReleaseName}?view=VIEW_FULL`
+    );
+    return Promise.resolve(data.release);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function watchUserPipelineReleaseQuery({
+  axiosInstance,
+  pipelineReleaseName
+}) {
+  try {
+    const { data } = await axiosInstance.get(
+      `/${pipelineReleaseName}/watch`
+    );
+    return Promise.resolve(data.state);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+export {
+  listPipelinesQuery,
+  listUserPipelinesQuery,
+  getUserPipelineQuery,
+  ListUserPipelineReleasesQuery,
+  getUserPipelineReleaseQuery,
+  watchUserPipelineReleaseQuery
+};

package/dist/chunk-EXJ4UK7Q.mjs

@@ -0,0 +1,49 @@
+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 __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 new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};

package/dist/chunk-GPM5FDRS.mjs

@@ -0,0 +1,154 @@
+import {
+  getQueryString
+} from "./chunk-EBWGEVUX.mjs";
+
+// src/connector/queries.ts
+async function listConnectorResourcesQuery({
+  axiosInstance,
+  pageSize,
+  nextPageToken,
+  filter
+}) {
+  try {
+    const connectors = [];
+    const queryString = getQueryString({
+      baseURL: `/connector-resources?view=VIEW_FULL`,
+      pageSize,
+      nextPageToken,
+      filter
+    });
+    const { data } = await axiosInstance.get(
+      queryString
+    );
+    connectors.push(...data.connector_resources);
+    if (data.next_page_token) {
+      connectors.push(
+        ...await listConnectorResourcesQuery({
+          axiosInstance,
+          pageSize,
+          nextPageToken: data.next_page_token,
+          filter
+        })
+      );
+    }
+    return Promise.resolve(connectors);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function listUserConnectorResourcesQuery({
+  axiosInstance,
+  userName,
+  pageSize,
+  nextPageToken,
+  filter
+}) {
+  try {
+    const connectors = [];
+    const queryString = getQueryString({
+      baseURL: `${userName}/connector-resources?view=VIEW_FULL`,
+      pageSize,
+      nextPageToken,
+      filter
+    });
+    const { data } = await axiosInstance.get(
+      queryString
+    );
+    connectors.push(...data.connector_resources);
+    if (data.next_page_token) {
+      connectors.push(
+        ...await listUserConnectorResourcesQuery({
+          axiosInstance,
+          userName,
+          pageSize,
+          nextPageToken: data.next_page_token,
+          filter
+        })
+      );
+    }
+    return Promise.resolve(connectors);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function listConnectorDefinitionsQuery({
+  axiosInstance,
+  pageSize,
+  nextPageToken,
+  filter
+}) {
+  try {
+    const connectorDefinitions = [];
+    const queryString = getQueryString({
+      baseURL: `/connector-definitions?view=VIEW_FULL`,
+      pageSize,
+      nextPageToken,
+      filter
+    });
+    const { data } = await axiosInstance.get(
+      queryString
+    );
+    connectorDefinitions.push(...data.connector_definitions);
+    if (data.next_page_token) {
+      connectorDefinitions.push(
+        ...await listConnectorDefinitionsQuery({
+          axiosInstance,
+          pageSize,
+          nextPageToken: data.next_page_token,
+          filter
+        })
+      );
+    }
+    return Promise.resolve(connectorDefinitions);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function getConnectorDefinitionQuery({
+  axiosInstance,
+  connectorDefinitionName
+}) {
+  try {
+    const { data } = await axiosInstance.get(
+      `/${connectorDefinitionName}?view=VIEW_FULL`
+    );
+    return Promise.resolve(data.connector_definition);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function getUserConnectorResourceQuery({
+  axiosInstance,
+  connectorResourceName
+}) {
+  try {
+    const { data } = await axiosInstance.get(
+      `/${connectorResourceName}?view=VIEW_FULL`
+    );
+    return Promise.resolve(data.connector_resource);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+async function watchUserConnectorResource({
+  axiosInstance,
+  connectorResourceName
+}) {
+  try {
+    const { data } = await axiosInstance.get(
+      `/${connectorResourceName}/watch`
+    );
+    return Promise.resolve(data);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+export {
+  listConnectorResourcesQuery,
+  listUserConnectorResourcesQuery,
+  listConnectorDefinitionsQuery,
+  getConnectorDefinitionQuery,
+  getUserConnectorResourceQuery,
+  watchUserConnectorResource
+};