@scalekit-sdk/node 1.0.0

package/lib/scalekit.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jose = __importStar(require("jose"));
+const qs_1 = __importDefault(require("qs"));
+const connect_1 = __importDefault(require("./connect"));
+const connection_1 = __importDefault(require("./connection"));
+const user_1 = require("./constants/user");
+const core_1 = __importDefault(require("./core"));
+const domain_1 = __importDefault(require("./domain"));
+const organization_1 = __importDefault(require("./organization"));
+const scalekit_1 = require("./types/scalekit");
+const authorizeEndpoint = "oauth/authorize";
+/**
+ * To initiate scalekit
+ * @param {string} envUrl The environment url
+ * @param {string} clientId The client id
+ * @param {string} clientSecret The client secret
+ * @returns {Scalekit} Returns the scalekit instance
+ * @example
+ * const scalekit = new Scalekit(envUrl, clientId, clientSecret);
+*/
+class Scalekit {
+    constructor(envUrl, clientId, clientSecret) {
+        this.coreClient = new core_1.default(envUrl, clientId, clientSecret);
+        this.grpcConnect = new connect_1.default(this.coreClient);
+        this.organization = new organization_1.default(this.grpcConnect, this.coreClient);
+        this.connection = new connection_1.default(this.grpcConnect, this.coreClient);
+        this.domain = new domain_1.default(this.grpcConnect, this.coreClient);
+    }
+    /**
+     * Returns the authorization url to initiate the authentication request.
+     * @param {string} redirectUri Redirect uri
+     * @param {AuthorizationUrlOptions} options Authorization url options
+     * @param {string[]} options.scopes Scopes to request from the user
+     * @param {string} options.state State parameter
+     * @param {string} options.nonce Nonce parameter
+     * @param {string} options.loginHint Login hint parameter
+     * @param {string} options.domainHint Domain hint parameter
+     * @param {string} options.connectionId Connection id parameter
+     * @param {string} options.organizationId Organization id parameter
+     *
+     * @example
+     * const scalekit = new Scalekit(envUrl, clientId, clientSecret);
+     * const authorizationUrl = scalekit.getAuthorizationUrl(redirectUri, { scopes: ['openid', 'profile'] });
+     * @returns {string} authorization url
+     */
+    getAuthorizationUrl(redirectUri, options) {
+        var _a;
+        const defaultOptions = {
+            scopes: ['openid', 'profile']
+        };
+        options = Object.assign(Object.assign({}, defaultOptions), options);
+        const qs = qs_1.default.stringify(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ response_type: 'code', client_id: this.coreClient.clientId, redirect_uri: redirectUri, scope: (_a = options.scopes) === null || _a === void 0 ? void 0 : _a.join(" ") }, (options.state && { state: options.state })), (options.nonce && { nonce: options.nonce })), (options.loginHint && { login_hint: options.loginHint })), (options.domainHint && { domain_hint: options.domainHint })), (options.domainHint && { domain: options.domainHint })), (options.connectionId && { connection_id: options.connectionId })), (options.organizationId && { organization_id: options.organizationId })));
+        return `${this.coreClient.envUrl}/${authorizeEndpoint}?${qs}`;
+    }
+    /**
+     * Authenticate with the code
+     * @param {CodeAuthenticationOptions} options Code authentication options
+     * @param {string} options.code Code
+     * @param {string} options.redirectUri Redirect uri
+     * @param {string} options.codeVerifier Code verifier
+     * @returns {Promise<{ user: Partial<User>, idToken: string, accessToken: string }>} Returns user, id token and access token
+     */
+    authenticateWithCode(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.coreClient.authenticate(qs_1.default.stringify(Object.assign({ code: options.code, redirect_uri: options.redirectUri, grant_type: scalekit_1.GrantType.AuthorizationCode, client_id: this.coreClient.clientId, client_secret: this.coreClient.clientSecret }, (options.codeVerifier && { code_verifier: options.codeVerifier }))));
+            const { id_token, access_token } = res.data;
+            const claims = jose.decodeJwt(id_token);
+            const user = {};
+            for (const [k, v] of Object.entries(claims)) {
+                if (user_1.IdTokenClaimToUserMap[k]) {
+                    user[user_1.IdTokenClaimToUserMap[k]] = v;
+                }
+            }
+            return {
+                user,
+                idToken: id_token,
+                accessToken: access_token
+            };
+        });
+    }
+    /**
+     * Validates the access token.
+     *
+     * @param {string} token The token to be validated.
+     * @return {Promise<boolean>} Returns true if the token is valid, false otherwise.
+     */
+    validateAccessToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.coreClient.getJwks();
+            const JWKS = jose.createLocalJWKSet({
+                keys: this.coreClient.keys
+            });
+            try {
+                yield jose.jwtVerify(token, JWKS);
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+}
+exports.default = Scalekit;
+//# sourceMappingURL=scalekit.js.map

package/lib/scalekit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalekit.js","sourceRoot":"","sources":["../src/scalekit.ts"],"names":[],"mappings":"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"}

package/lib/types/scalekit.d.ts

@@ -0,0 +1,26 @@
+export declare enum GrantType {
+    AuthorizationCode = "authorization_code",
+    RefreshToken = "refresh_token",
+    ClientCredentials = "client_credentials"
+}
+export type AuthorizationUrlOptions = {
+    connectionId?: string;
+    organizationId?: string;
+    scopes?: string[];
+    state?: string;
+    nonce?: string;
+    domainHint?: string;
+    loginHint?: string;
+};
+export type CodeAuthenticationOptions = {
+    code: string;
+    redirectUri: string;
+    codeVerifier?: string;
+};
+export type RefreshTokenAuthenticationOptions = {
+    code: string;
+    redirectUri: string;
+};
+export type AuthenticationOptions = {
+    refreshToken: string;
+};

package/lib/types/scalekit.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrantType = void 0;
+var GrantType;
+(function (GrantType) {
+    GrantType["AuthorizationCode"] = "authorization_code";
+    GrantType["RefreshToken"] = "refresh_token";
+    GrantType["ClientCredentials"] = "client_credentials";
+})(GrantType || (exports.GrantType = GrantType = {}));
+//# sourceMappingURL=scalekit.js.map

package/lib/types/scalekit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalekit.js","sourceRoot":"","sources":["../../src/types/scalekit.ts"],"names":[],"mappings":";;;AAAA,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,qDAAwC,CAAA;IACxC,2CAA8B,CAAA;IAC9B,qDAAwC,CAAA;AAC1C,CAAC,EAJW,SAAS,yBAAT,SAAS,QAIpB"}

package/lib/types/user.d.ts

@@ -0,0 +1,56 @@
+export type User = {
+    id: string;
+    username: string | undefined;
+    name: string;
+    givenName: string;
+    familyName: string | undefined;
+    email: string;
+    emailVerified: boolean;
+    phoneNumber: string | undefined;
+    phoneNumberVerified: boolean | undefined;
+    profile: string | undefined;
+    picture: string | undefined;
+    gender: string | undefined;
+    birthDate: string | undefined;
+    zoneInfo: string | undefined;
+    locale: string | undefined;
+    updatedAt: string | undefined;
+    identities: Identity[];
+    metadata: string | undefined;
+};
+export type Identity = {
+    connectionId: string;
+    organizationId: string;
+    connectionType: string;
+    providerName: string;
+    social: boolean;
+    providerRawAttributes: string;
+};
+export type IdTokenClaimIdentity = {
+    connection_id: string;
+    organization_id: string;
+    connection_type: string;
+    provider_name: string;
+    social: boolean;
+    provider_raw_attributes: string;
+};
+export type IdTokenClaim = {
+    sub: string;
+    name: string;
+    preferred_username: string | undefined;
+    given_name: string;
+    family_name: string | undefined;
+    email: string;
+    email_verified: boolean;
+    phone_number: string | undefined;
+    phone_number_verified: boolean | undefined;
+    profile: string | undefined;
+    picture: string | undefined;
+    gender: string | undefined;
+    birthdate: string | undefined;
+    zoneinfo: string | undefined;
+    locale: string | undefined;
+    updated_at: string | undefined;
+    identities: IdTokenClaimIdentity[];
+    metadata: string | undefined;
+};

package/lib/types/user.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=user.js.map

package/lib/types/user.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.js","sourceRoot":"","sources":["../../src/types/user.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "version": "1.0.0",
+  "name": "@scalekit-sdk/node",
+  "description": "Scalekit Node SDK",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scalekit-inc/scalekit-sdk-node.git"
+  },
+  "scripts": {
+    "generate": "npx buf generate $npm_config_src",
+    "build": "rm -rf lib && tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "scalekit"
+  ],
+  "author": "Scalekit Team",
+  "license": "ISC",
+  "dependencies": {
+    "@connectrpc/connect": "^1.4.0",
+    "@connectrpc/connect-node": "^1.4.0",
+    "axios": "^1.6.8",
+    "jose": "^5.2.4",
+    "qs": "^6.12.1"
+  },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.30.1",
+    "@bufbuild/protobuf": "^1.8.0",
+    "@bufbuild/protoc-gen-es": "^1.8.0",
+    "@connectrpc/protoc-gen-connect-es": "^1.4.0",
+    "@types/node": "^20.12.7",
+    "@types/qs": "^6.9.15",
+    "typescript": "^5.4.5"
+  },
+  "bugs": {
+    "url": "https://github.com/scalekit-inc/scalekit-sdk-node/issues"
+  },
+  "homepage": "https://github.com/scalekit-inc/scalekit-sdk-node#readme",
+  "directories": {
+    "example": "examples",
+    "lib": "lib"
+  }
+}

package/src/connect.ts

@@ -0,0 +1,33 @@
+import { ServiceType } from '@bufbuild/protobuf';
+import { PromiseClient, Transport, createPromiseClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import CoreClient from './core';
+
+export default class GrpcConnect {
+  private transport: Transport;
+  constructor(
+    private readonly coreClient: CoreClient
+  ) {
+    this.transport = createGrpcTransport({
+      baseUrl: this.coreClient.envUrl,
+      httpVersion: "2",
+      interceptors: [
+        (next) => {
+          return (req) => {
+            req.header.set("User-Agent", this.coreClient.userAgent)
+            req.header.set("x-sdk-version", this.coreClient.sdkVersion)
+            req.header.set("x-api-version", this.coreClient.apiVersion)
+            if (this.coreClient.accessToken) {
+              req.header.set("Authorization", `Bearer ${this.coreClient.accessToken}`)
+            }
+            return next(req)
+          }
+        }
+      ],
+    });
+  }
+
+  createClient<T extends ServiceType>(service: T): PromiseClient<T> {
+    return createPromiseClient(service, this.transport);
+  }
+}

package/src/connection.ts

@@ -0,0 +1,69 @@
+import { PromiseClient } from '@connectrpc/connect';
+import GrpcConnect from './connect';
+import CoreClient from './core';
+import { ConnectionService } from './pkg/grpc/scalekit/v1/connections/connections_connect';
+import { GetConnectionResponse, ListConnectionsResponse } from './pkg/grpc/scalekit/v1/connections/connections_pb';
+
+export default class ConnectionClient {
+  private client: PromiseClient<typeof ConnectionService>;
+  constructor(
+    private readonly grpcConncet: GrpcConnect,
+    private readonly coreClient: CoreClient
+  ) {
+    this.client = this.grpcConncet.createClient(ConnectionService);
+  }
+
+  /**
+   * Get a connection by id and organization id
+   * @param id The connection id
+   * @param organizationId The organization id
+   * @returns {Promise<GetConnectionResponse>} The connection
+   */
+  async getConnection(id: string, organizationId: string): Promise<GetConnectionResponse> {
+    return this.coreClient.connectExec(
+      this.client.getConnection,
+      {
+        id,
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        }
+      },
+    )
+  }
+
+  /**
+   * List connections by domain
+   * @param domain The domain
+   * @returns {Promise<ListConnectionsResponse>} The connection
+   */
+  async listConnectionsByDomain(domain: string): Promise<ListConnectionsResponse> {
+    return this.coreClient.connectExec(
+      this.client.listConnections,
+      {
+        identities: {
+          case: 'domain',
+          value: domain
+        }
+      },
+    )
+  }
+
+  /**
+   * List connections by organization id
+   * @param organizationId The organization id
+   * @returns {Promise<ListConnectionsResponse>} The list of connections
+   */
+  async listConnections(organizationId: string): Promise<ListConnectionsResponse> {
+    return this.coreClient.connectExec(
+      this.client.listConnections,
+      {
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        }
+      },
+    )
+  }
+}
+

package/src/constants/user.ts

@@ -0,0 +1,22 @@
+import type { IdTokenClaim, User } from '../types/user';
+
+export const IdTokenClaimToUserMap: { [k in keyof IdTokenClaim]: keyof User } = {
+  "sub": "id",
+  "name": "name",
+  "preferred_username": "username",
+  "given_name": "givenName",
+  "family_name": "familyName",
+  "email": "email",
+  "email_verified": "emailVerified",
+  "phone_number": "phoneNumber",
+  "phone_number_verified": "phoneNumberVerified",
+  "profile": 'profile',
+  "picture": "picture",
+  "gender": "gender",
+  "birthdate": "birthDate",
+  "zoneinfo": "zoneInfo",
+  "locale": "locale",
+  "updated_at": "updatedAt",
+  "identities": "identities",
+  "metadata": "metadata"
+}

package/src/core.ts

@@ -0,0 +1,127 @@
+import { Code, ConnectError } from '@connectrpc/connect';
+import axios, { Axios, AxiosError, AxiosResponse, HttpStatusCode } from "axios";
+import { JWK } from 'jose';
+import os from "os";
+import QueryString from "qs";
+import { GrantType } from './types/scalekit';
+import { ErrorInfo } from './pkg/grpc/scalekit/v1/errdetails/errdetails_pb';
+
+const tokenEndpoint = "oauth/token";
+const jwksEndpoint = "keys";
+export default class CoreClient {
+  public keys: JWK[] = [];
+  public accessToken: string | null = null;
+  public axios: Axios;
+  public sdkVersion = `Scalekit-Node/1.0.0`;
+  public apiVersion = "20240430";
+  public userAgent = `${this.sdkVersion} Node/${process.version} (${process.platform}; ${os.arch()})`;
+  constructor(
+    readonly envUrl: string,
+    readonly clientId: string,
+    readonly clientSecret: string
+  ) {
+    this.axios = axios.create({ baseURL: envUrl });
+    this.axios.interceptors.request.use((config) => {
+      config.headers["User-Agent"] = this.userAgent;
+      config.headers["x-sdk-version"] = this.sdkVersion;
+      config.headers["x-api-version"] = this.apiVersion;
+      if (this.accessToken) {
+        config.headers["Authorization"] = `Bearer ${this.accessToken}`;
+      }
+
+      return config;
+    });
+    this.authenticateClient();
+  }
+
+  private async authenticateClient() {
+    const res = await this.authenticate(QueryString.stringify({
+      grant_type: GrantType.ClientCredentials,
+      client_id: this.clientId,
+      client_secret: this.clientSecret
+    }))
+
+    this.accessToken = res.data.access_token;
+  }
+  /**
+   * Authenticate with the code
+   * @param {string} data Data to authenticate
+   * @returns {Promise<AxiosResponse<{ access_token: string, id_token: string }>>} Returns access token and id token
+   */
+  async authenticate(data: string): Promise<AxiosResponse<{ access_token: string; id_token: string; }, any>> {
+    return this.axios.post<{ access_token: string, id_token: string }>(
+      tokenEndpoint,
+      data,
+      {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      }
+    )
+  }
+
+  /**
+   * Get the JWKS from the server and store it in the client instance
+   * @returns {Promise<void>} Returns nothing   
+   */
+  async getJwks(): Promise<void> {
+    if (this.keys.length) {
+      return Promise.resolve();
+    }
+    const { data: { keys } } = await this.axios.get<{ keys: JWK[] }>(jwksEndpoint);
+    this.keys = keys;
+  }
+
+  /**
+   * 
+   * @param fn Function to execute
+   * @param data Data to pass to the function
+   * @param retryLeft Number of retries left
+   * @returns {Promise<TResponse>} Returns the response
+   */
+  async connectExec<TRequest, TResponse>(
+    fn: (request: TRequest) => Promise<TResponse>,
+    data: TRequest,
+    retryLeft: number = 1,
+  ): Promise<TResponse> {
+    try {
+      const res = await fn(data);
+      return res;
+    } catch (error) {
+      if (retryLeft > 0) {
+        let isUnauthenticatedError = false;
+        if (error instanceof AxiosError) {
+          if (error.status == HttpStatusCode.Unauthorized) {
+            isUnauthenticatedError = true;
+          } else {
+            throw new Error(error.message);
+          }
+        }
+        // ConnectError is a custom error class that extends Error class and has a code property
+        if (error instanceof ConnectError) {
+          if (error.code == Code.Unauthenticated) {
+            isUnauthenticatedError = true;
+          } else {
+            if (error.code == Code.InvalidArgument) {
+              const message = error.findDetails(ErrorInfo).map((detail) => {
+                if (detail.validationErrorInfo) {
+                  return detail.validationErrorInfo.fieldViolations.map((fv) => {
+                    return `${fv.field}: ${fv.description}`
+                  }).join("\n")
+                }
+                return error.message;
+              }).join("\n")
+              throw new Error(message);
+            }
+            throw new Error(error.message);
+          }
+        }
+        if (isUnauthenticatedError) {
+          await this.authenticateClient();
+          return this.connectExec(fn, data, retryLeft - 1);
+        }
+      }
+      throw error;
+    }
+  }
+}

package/src/domain.ts

@@ -0,0 +1,75 @@
+import { PromiseClient } from '@connectrpc/connect';
+import GrpcConnect from './connect';
+import CoreClient from './core';
+import { DomainService } from './pkg/grpc/scalekit/v1/domains/domains_connect';
+import { CreateDomainResponse, GetDomainResponse, ListDomainResponse } from './pkg/grpc/scalekit/v1/domains/domains_pb';
+
+export default class DomainClient {
+  private client: PromiseClient<typeof DomainService>;
+  constructor(
+    private readonly grpcConncet: GrpcConnect,
+    private readonly coreClient: CoreClient
+  ) {
+    this.client = this.grpcConncet.createClient(DomainService);
+  }
+
+  /**
+   * Create a domain for an organization with the given name. Optionally, you can provide an external id. 
+   * @param {string} organizationId  The organization id
+   * @param {string} name The domain name
+   * @returns {Promise<CreateDomainResponse>} The created domain
+  */
+  async createDomain(organizationId: string, name: string): Promise<CreateDomainResponse> {
+    return this.coreClient.connectExec(
+      this.client.createDomain,
+      {
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        },
+        domain: {
+          domain: name
+        }
+      }
+    )
+  }
+
+  /**
+   * Get a domain by id  
+   * @param {object} options The options to get a domain
+   * @param {string} options.id The domain id
+   * @param {string} options.organizationId The organization id
+   * @returns {Promise<GetDomainResponse>} The domain
+  */
+  async getDomain(options: { id: string, organizationId: string }): Promise<GetDomainResponse> {
+    const { id, organizationId } = options;
+    return this.coreClient.connectExec(
+      this.client.getDomain,
+      {
+        id,
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        }
+      }
+    )
+  }
+
+  /**
+   * List domains for an organization 
+   * @param organizationId The organization id
+   * @returns {Promise<ListDomainResponse>} The list of domains for the organization
+   */
+  async listDomains(organizationId: string): Promise<ListDomainResponse> {
+    return this.coreClient.connectExec(
+      this.client.listDomains,
+      {
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        }
+      },
+    );
+  }
+}
+

package/src/index.ts

@@ -0,0 +1,7 @@
+import Scalekit from "./scalekit";
+
+export { Scalekit };
+export default Scalekit;
+
+export * from "./types/scalekit";
+export * from "./types/user";