@makeplane/plane-node-sdk 0.1.0 → 0.1.1

package/README.md

@@ -1,4 +1,4 @@
-## @makeplane/plane-node-sdk@0.1.0
+## @makeplane/plane-node-sdk@0.1.1
 
 This generator creates TypeScript/JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments:
 
@@ -36,7 +36,7 @@ navigate to the folder of your consuming project and run one of the following co
 _published:_
 
 ```
-npm install @makeplane/plane-node-sdk@0.1.0 --save
+npm install @makeplane/plane-node-sdk@0.1.1 --save
 ```
 
 _unPublished (not recommended):_

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './runtime';
 export * from './apis/index';
 export * from './models/index';
+export * from "./oauth/api";

package/dist/index.js

@@ -18,3 +18,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./runtime"), exports);
 __exportStar(require("./apis/index"), exports);
 __exportStar(require("./models/index"), exports);
+__exportStar(require("./oauth/api"), exports);

package/dist/oauth/api.d.ts

@@ -0,0 +1,54 @@
+import * as runtime from "../runtime";
+import { PlaneOAuthTokenResponse, PlaneOAuthAppInstallation } from "./models";
+/**
+ * OAuth API helper class
+ */
+export declare class OAuthApi extends runtime.BaseAPI {
+    private clientId;
+    private clientSecret;
+    private redirectUri;
+    private baseUrl;
+    constructor(configuration: runtime.Configuration, oauthConfig: {
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+    });
+    /**
+     * Get the authorization URL for the OAuth flow
+     * @param responseType - The response type (default: "code")
+     * @param state - Optional state parameter for security
+     * @returns The authorization URL
+     */
+    getAuthorizationUrl(responseType?: string, state?: string): string;
+    /**
+     * Exchange authorization code for access token
+     * @param code - The authorization code
+     * @param grantType - The grant type (default: "authorization_code")
+     * @returns Promise resolving to token response
+     */
+    exchangeCodeForToken(code: string, grantType?: string): Promise<PlaneOAuthTokenResponse>;
+    /**
+     * Get a new access token using a refresh token
+     * @param refreshToken - The refresh token
+     * @returns Promise resolving to token response
+     */
+    getRefreshToken(refreshToken: string): Promise<PlaneOAuthTokenResponse>;
+    /**
+     * Get a new access token using client credentials for bot/app installations
+     * @param appInstallationId - The app installation ID
+     * @returns Promise resolving to token response
+     */
+    getBotToken(appInstallationId: string): Promise<PlaneOAuthTokenResponse>;
+    /**
+     * Get an app installation by ID using the bot token
+     * @param token - The bot token from getBotToken method
+     * @param appInstallationId - The app installation ID
+     * @returns Promise resolving to app installation
+     */
+    getAppInstallation(token: string, appInstallationId: string): Promise<PlaneOAuthAppInstallation>;
+    /**
+     * Generate basic auth token from client_id and client_secret
+     * @returns Base64 encoded basic auth token
+     */
+    private getBasicAuthToken;
+}

package/dist/oauth/api.js

@@ -0,0 +1,237 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuthApi = void 0;
+var runtime = require("../runtime");
+/**
+ * OAuth API helper class
+ */
+var OAuthApi = /** @class */ (function (_super) {
+    __extends(OAuthApi, _super);
+    function OAuthApi(configuration, oauthConfig) {
+        var _this = _super.call(this, configuration) || this;
+        _this.clientId = oauthConfig.clientId;
+        _this.clientSecret = oauthConfig.clientSecret;
+        _this.redirectUri = oauthConfig.redirectUri;
+        _this.baseUrl = configuration.basePath || "https://api.plane.so";
+        return _this;
+    }
+    /**
+     * Get the authorization URL for the OAuth flow
+     * @param responseType - The response type (default: "code")
+     * @param state - Optional state parameter for security
+     * @returns The authorization URL
+     */
+    OAuthApi.prototype.getAuthorizationUrl = function (responseType, state) {
+        if (responseType === void 0) { responseType = "code"; }
+        var params = new URLSearchParams({
+            client_id: this.clientId,
+            response_type: responseType,
+            redirect_uri: this.redirectUri,
+        });
+        if (state) {
+            params.append("state", state);
+        }
+        return "".concat(this.baseUrl, "/auth/o/authorize-app/?").concat(params.toString());
+    };
+    /**
+     * Exchange authorization code for access token
+     * @param code - The authorization code
+     * @param grantType - The grant type (default: "authorization_code")
+     * @returns Promise resolving to token response
+     */
+    OAuthApi.prototype.exchangeCodeForToken = function (code_1) {
+        return __awaiter(this, arguments, void 0, function (code, grantType) {
+            var data, headers, response;
+            if (grantType === void 0) { grantType = "authorization_code"; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = new URLSearchParams({
+                            grant_type: grantType,
+                            code: code,
+                            client_id: this.clientId,
+                            client_secret: this.clientSecret,
+                            redirect_uri: this.redirectUri,
+                        });
+                        headers = {
+                            "Cache-Control": "no-cache",
+                            "Content-Type": "application/x-www-form-urlencoded",
+                        };
+                        return [4 /*yield*/, this.request({
+                                path: "/auth/o/token/",
+                                method: "POST",
+                                headers: headers,
+                                body: data,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get a new access token using a refresh token
+     * @param refreshToken - The refresh token
+     * @returns Promise resolving to token response
+     */
+    OAuthApi.prototype.getRefreshToken = function (refreshToken) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, headers, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = new URLSearchParams({
+                            grant_type: "refresh_token",
+                            refresh_token: refreshToken,
+                            client_id: this.clientId,
+                            client_secret: this.clientSecret,
+                        });
+                        headers = {
+                            "Cache-Control": "no-cache",
+                            "Content-Type": "application/x-www-form-urlencoded",
+                        };
+                        return [4 /*yield*/, this.request({
+                                path: "/auth/o/token/",
+                                method: "POST",
+                                headers: headers,
+                                body: data,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get a new access token using client credentials for bot/app installations
+     * @param appInstallationId - The app installation ID
+     * @returns Promise resolving to token response
+     */
+    OAuthApi.prototype.getBotToken = function (appInstallationId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, headers, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = new URLSearchParams({
+                            grant_type: "client_credentials",
+                            app_installation_id: appInstallationId,
+                        });
+                        headers = {
+                            "Cache-Control": "no-cache",
+                            "Content-Type": "application/x-www-form-urlencoded",
+                            Authorization: "Basic ".concat(this.getBasicAuthToken()),
+                        };
+                        return [4 /*yield*/, this.request({
+                                path: "/auth/o/token/",
+                                method: "POST",
+                                headers: headers,
+                                body: data,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get an app installation by ID using the bot token
+     * @param token - The bot token from getBotToken method
+     * @param appInstallationId - The app installation ID
+     * @returns Promise resolving to app installation
+     */
+    OAuthApi.prototype.getAppInstallation = function (token, appInstallationId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers, response, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        headers = {
+                            Authorization: "Bearer ".concat(token),
+                        };
+                        return [4 /*yield*/, this.request({
+                                path: "/auth/o/app-installation/?id=".concat(appInstallationId),
+                                method: "GET",
+                                headers: headers,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        data = _a.sent();
+                        if (!data || data.length === 0) {
+                            throw new runtime.ResponseError(response, "App installation not found");
+                        }
+                        return [2 /*return*/, data[0]];
+                }
+            });
+        });
+    };
+    /**
+     * Generate basic auth token from client_id and client_secret
+     * @returns Base64 encoded basic auth token
+     */
+    OAuthApi.prototype.getBasicAuthToken = function () {
+        var credentials = "".concat(this.clientId, ":").concat(this.clientSecret);
+        return btoa(credentials);
+    };
+    return OAuthApi;
+}(runtime.BaseAPI));
+exports.OAuthApi = OAuthApi;

package/dist/oauth/models.d.ts

@@ -0,0 +1,28 @@
+export interface PlaneOAuthTokenResponse {
+    access_token: string;
+    expires_in?: number;
+    token_type: string;
+    scope?: string;
+    refresh_token?: string;
+}
+export interface WorkspaceDetail {
+    name: string;
+    slug: string;
+    id: string;
+    logo_url?: string;
+}
+export interface PlaneOAuthAppInstallation {
+    id: string;
+    workspace_detail: WorkspaceDetail;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    status: string;
+    created_by?: string;
+    updated_by?: string;
+    workspace: string;
+    application: string;
+    installed_by: string;
+    app_bot: string;
+    webhook?: string;
+}

package/dist/oauth/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makeplane/plane-node-sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Node SDK for Plane",
   "author": "Plane <support@plane.so>",
   "repository": {

package/src/index.ts

@@ -3,3 +3,4 @@
 export * from './runtime';
 export * from './apis/index';
 export * from './models/index';
+export * from "./oauth/api";

package/src/oauth/api.ts

@@ -0,0 +1,176 @@
+import * as runtime from "../runtime";
+import { PlaneOAuthTokenResponse, PlaneOAuthAppInstallation } from "./models";
+
+/**
+ * OAuth API helper class
+ */
+export class OAuthApi extends runtime.BaseAPI {
+  private clientId: string;
+  private clientSecret: string;
+  private redirectUri: string;
+  private baseUrl: string;
+
+  constructor(
+    configuration: runtime.Configuration,
+    oauthConfig: {
+      clientId: string;
+      clientSecret: string;
+      redirectUri: string;
+    }
+  ) {
+    super(configuration);
+    this.clientId = oauthConfig.clientId;
+    this.clientSecret = oauthConfig.clientSecret;
+    this.redirectUri = oauthConfig.redirectUri;
+    this.baseUrl = configuration.basePath || "https://api.plane.so";
+  }
+
+  /**
+   * Get the authorization URL for the OAuth flow
+   * @param responseType - The response type (default: "code")
+   * @param state - Optional state parameter for security
+   * @returns The authorization URL
+   */
+  getAuthorizationUrl(responseType: string = "code", state?: string): string {
+    const params = new URLSearchParams({
+      client_id: this.clientId,
+      response_type: responseType,
+      redirect_uri: this.redirectUri,
+    });
+
+    if (state) {
+      params.append("state", state);
+    }
+
+    return `${this.baseUrl}/auth/o/authorize-app/?${params.toString()}`;
+  }
+
+  /**
+   * Exchange authorization code for access token
+   * @param code - The authorization code
+   * @param grantType - The grant type (default: "authorization_code")
+   * @returns Promise resolving to token response
+   */
+  async exchangeCodeForToken(
+    code: string,
+    grantType: string = "authorization_code"
+  ): Promise<PlaneOAuthTokenResponse> {
+    const data = new URLSearchParams({
+      grant_type: grantType,
+      code: code,
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      redirect_uri: this.redirectUri,
+    });
+
+    const headers: runtime.HTTPHeaders = {
+      "Cache-Control": "no-cache",
+      "Content-Type": "application/x-www-form-urlencoded",
+    };
+
+    const response = await this.request({
+      path: `/auth/o/token/`,
+      method: "POST",
+      headers: headers,
+      body: data,
+    });
+
+    return await response.json();
+  }
+
+  /**
+   * Get a new access token using a refresh token
+   * @param refreshToken - The refresh token
+   * @returns Promise resolving to token response
+   */
+  async getRefreshToken(
+    refreshToken: string
+  ): Promise<PlaneOAuthTokenResponse> {
+    const data = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+    });
+
+    const headers: runtime.HTTPHeaders = {
+      "Cache-Control": "no-cache",
+      "Content-Type": "application/x-www-form-urlencoded",
+    };
+
+    const response = await this.request({
+      path: `/auth/o/token/`,
+      method: "POST",
+      headers: headers,
+      body: data,
+    });
+
+    return await response.json();
+  }
+
+  /**
+   * Get a new access token using client credentials for bot/app installations
+   * @param appInstallationId - The app installation ID
+   * @returns Promise resolving to token response
+   */
+  async getBotToken(
+    appInstallationId: string
+  ): Promise<PlaneOAuthTokenResponse> {
+    const data = new URLSearchParams({
+      grant_type: "client_credentials",
+      app_installation_id: appInstallationId,
+    });
+
+    const headers: runtime.HTTPHeaders = {
+      "Cache-Control": "no-cache",
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${this.getBasicAuthToken()}`,
+    };
+
+    const response = await this.request({
+      path: `/auth/o/token/`,
+      method: "POST",
+      headers: headers,
+      body: data,
+    });
+
+    return await response.json();
+  }
+
+  /**
+   * Get an app installation by ID using the bot token
+   * @param token - The bot token from getBotToken method
+   * @param appInstallationId - The app installation ID
+   * @returns Promise resolving to app installation
+   */
+  async getAppInstallation(
+    token: string,
+    appInstallationId: string
+  ): Promise<PlaneOAuthAppInstallation> {
+    const headers: runtime.HTTPHeaders = {
+      Authorization: `Bearer ${token}`,
+    };
+
+    const response = await this.request({
+      path: `/auth/o/app-installation/?id=${appInstallationId}`,
+      method: "GET",
+      headers: headers,
+    });
+
+    const data = await response.json();
+    if (!data || data.length === 0) {
+      throw new runtime.ResponseError(response, "App installation not found");
+    }
+
+    return data[0];
+  }
+
+  /**
+   * Generate basic auth token from client_id and client_secret
+   * @returns Base64 encoded basic auth token
+   */
+  private getBasicAuthToken(): string {
+    const credentials = `${this.clientId}:${this.clientSecret}`;
+    return btoa(credentials);
+  }
+}

package/src/oauth/models.ts

@@ -0,0 +1,30 @@
+export interface PlaneOAuthTokenResponse {
+  access_token: string;
+  expires_in?: number;
+  token_type: string;
+  scope?: string;
+  refresh_token?: string;
+}
+
+export interface WorkspaceDetail {
+  name: string;
+  slug: string;
+  id: string;
+  logo_url?: string;
+}
+
+export interface PlaneOAuthAppInstallation {
+  id: string;
+  workspace_detail: WorkspaceDetail;
+  created_at: string;
+  updated_at: string;
+  deleted_at?: string;
+  status: string;
+  created_by?: string;
+  updated_by?: string;
+  workspace: string;
+  application: string;
+  installed_by: string;
+  app_bot: string;
+  webhook?: string;
+}