@faable/deploy-sdk 1.0.0

package/src/auth/apikey.ts

@@ -0,0 +1,11 @@
+import { FetcherCreateParams } from "../fetcher/Fetcher.js";
+
+export const createApikeyAuth = (
+  apikey: string = process.env.FAABLE_APIKEY || ""
+): FetcherCreateParams => {
+  return {
+    headers: {
+      authorization: `basic ${btoa(`${apikey}:${apikey}`)}`,
+    },
+  };
+};

package/src/fetcher/Fetcher.ts

@@ -0,0 +1,42 @@
+type Method =
+  | "get"
+  | "GET"
+  | "delete"
+  | "DELETE"
+  | "head"
+  | "HEAD"
+  | "options"
+  | "OPTIONS"
+  | "post"
+  | "POST"
+  | "put"
+  | "PUT"
+  | "patch"
+  | "PATCH"
+  | "purge"
+  | "PURGE"
+  | "link"
+  | "LINK"
+  | "unlink"
+  | "UNLINK";
+export type FetcherRequestParams = {
+  url: string;
+  method?: Method;
+  params?: any;
+};
+
+export type Headers = {
+  authorization?: string;
+};
+
+export type FetcherCreateParams = {
+  baseURL?: string;
+  headers?: Headers;
+};
+
+export type Fetcher = {
+  get: <T>(url: string) => Promise<T>;
+  post: <T>(url: string, data: any) => Promise<T>;
+  request: <T>(params: FetcherRequestParams) => Promise<T>;
+  check: <T>(url: string, status?: number) => Promise<boolean>;
+};

package/src/fetcher/fetcher_axios.ts

@@ -0,0 +1,50 @@
+import axios, { AxiosError } from "axios";
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+import { FaableApiError } from "../helpers/error_handler.js";
+import { Fetcher, FetcherCreateParams } from "./Fetcher.js";
+
+const handleErrorInterceptor = async (e: AxiosError) => {
+  const data: any = e.response?.data;
+  throw new FaableApiError(
+    `FaableApiError: ${data?.message} (status=${e.response?.status}, url=${e.response?.config.url})`
+  );
+};
+
+export const fetcher_axios = (params: FetcherCreateParams = {}): Fetcher => {
+  const instance = axios.create(params);
+  // Add base interceptor
+  instance.interceptors.response.use((res: AxiosResponse) => {
+    //console.log(`Request ${res.config.url}`);
+    return res;
+  }, handleErrorInterceptor);
+
+  return {
+    get: async <T>(url: string) => {
+      const res = await instance.request<T>({
+        method: "GET",
+        url,
+      });
+      return res.data;
+    },
+    post: async <T>(url: string, data: any) => {
+      const res = await instance.request<T>({
+        method: "GET",
+        url,
+        data,
+      });
+      return res.data;
+    },
+    request: async <T>(params: AxiosRequestConfig) => {
+      const res = await instance.request<T>(params);
+      return res.data;
+    },
+    check: async <T>(url: string) => {
+      const res = await instance.request<T>({
+        method: "GET",
+        url,
+        validateStatus: () => true,
+      });
+      return res.status == 200;
+    },
+  };
+};

package/src/helpers/authorize-client-credentials.ts

@@ -0,0 +1,54 @@
+import axios, { AxiosInstance } from "axios";
+import { jwtDecode } from "jwt-decode";
+
+export type ClientCredentialsConfig = {
+  domain: string;
+  clientId: string;
+  clientSecret: string;
+};
+
+export interface ClientCredentialsResponse {
+  access_token: string;
+}
+
+export class ClientCredentialsFlow {
+  constructor(private config: ClientCredentialsConfig) {}
+
+  private response?: ClientCredentialsResponse;
+
+  private isTokenExpired() {
+    if (!this.response) throw new Error("No token");
+    let { exp } = jwtDecode(this.response?.access_token);
+    if (!exp) {
+      throw new Error("Missing expire date");
+    }
+    const currentSeconds = new Date().getTime() / 1000;
+    return currentSeconds > exp;
+  }
+
+  private async _getToken() {
+    const params = new URLSearchParams();
+    params.append("grant_type", "client_credentials");
+    params.append("client_id", this.config.clientId);
+    params.append("client_secret", this.config.clientSecret);
+    const res = await axios.post<ClientCredentialsResponse>(
+      this.config.domain + "/oauth/token",
+      params
+    );
+    this.response = res.data;
+    console.log(
+      `[${this.config.domain}] ✅ Client Credentials flow completed `
+    );
+    return this.response;
+  }
+
+  async getToken() {
+    if (!this.response || this.isTokenExpired()) {
+      await this._getToken();
+    }
+    if (!this.response?.access_token) {
+      throw new Error("Cannot get token");
+    }
+    return this.response?.access_token;
+  }
+}

package/src/helpers/authorize.ts

@@ -0,0 +1,58 @@
+import axios, { AxiosInstance } from "axios";
+
+import {
+  ClientCredentialsFlow,
+  ClientCredentialsConfig,
+} from "./authorize-client-credentials.js";
+
+interface AuthConfig {
+  client?: AxiosInstance;
+  client_credentials?: ClientCredentialsConfig;
+}
+
+export const authorize = (_config?: AuthConfig) => {
+  const authDomain =
+    process.env.FAABLEAUTH_DOMAIN || _config?.client_credentials?.domain || "";
+  if (!authDomain) {
+    throw new Error("Setup Faable Auth failed, missing env FAABLEAUTH_DOMAIN");
+  }
+  const client_credentials_config: ClientCredentialsConfig = {
+    domain: authDomain,
+    clientId:
+      process.env.FAABLEAUTH_CLIENT_ID ||
+      _config?.client_credentials?.clientId ||
+      "",
+    clientSecret:
+      process.env.FAABLEAUTH_CLIENT_SECRET ||
+      _config?.client_credentials?.clientSecret ||
+      "",
+  };
+
+  // Reuse client or setup a new one
+  const client = _config?.client || axios.create({ baseURL: authDomain });
+
+  // Config is OK
+  let enable_client_credentials = false;
+  if (
+    client_credentials_config.domain &&
+    client_credentials_config.clientId &&
+    client_credentials_config.clientSecret
+  ) {
+    enable_client_credentials = true;
+    console.log(
+      `[${client_credentials_config.domain}] Using client credentials`
+    );
+  } else {
+    console.warn(`Client credentials not configured`);
+  }
+
+  const flow = new ClientCredentialsFlow(client_credentials_config);
+  client.interceptors.request.use(async function (config) {
+    if (enable_client_credentials) {
+      const token = await flow.getToken();
+      config.headers.set("Authorization", `Bearer ${token}`);
+    }
+    return config;
+  });
+  return client;
+};

package/src/helpers/error_handler.ts

@@ -0,0 +1,7 @@
+export class FaableApiError extends Error {
+  constructor(msg: string) {
+    super(msg);
+    this.name = "FaableApiError";
+    Object.setPrototypeOf(this, FaableApiError.prototype);
+  }
+}

package/src/helpers/paginator.ts

@@ -0,0 +1,37 @@
+import { Fetcher, FetcherRequestParams } from "../fetcher/Fetcher.js";
+
+export interface Page<T> {
+  next: string | null;
+  results: T[];
+}
+export type Paginator = ReturnType<typeof buildPaginator>;
+export const buildPaginator =
+  (fetcher: Fetcher) =>
+  <T>(req: FetcherRequestParams) => {
+    return {
+      all: async () => {
+        const pages: Page<T>[] = [];
+        let data: Page<T> | undefined;
+        do {
+          data = await fetcher.request<Page<T>>({
+            ...req,
+            params: { ...req.params, next: data && data?.next },
+          });
+          pages.push(data);
+        } while (data.next);
+        return pages.map((page) => page.results).flat();
+      },
+      first: async () => {
+        return fetcher.request<Page<T>>(req);
+      },
+      pass: async (params: { cursor?: string; pageSize?: string } = {}) => {
+        return fetcher.request<Page<T>>({
+          ...req,
+          params: {
+            ...req.params,
+            ...params,
+          },
+        });
+      },
+    };
+  };

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./FaableDeployApi.js";

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "rootDir": "./src",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts"]
+}