@scalekit-sdk/node 1.0.9 → 1.0.11

package/src/passwordless.ts

@@ -0,0 +1,135 @@
+import { PromiseClient } from '@connectrpc/connect';
+import GrpcConnect from './connect';
+import CoreClient from './core';
+import { PasswordlessService } from './pkg/grpc/scalekit/v1/auth/passwordless_connect';
+import { 
+  SendPasswordlessResponse, 
+  VerifyPasswordLessResponse,
+  TemplateType,
+  SendPasswordlessRequest,
+  VerifyPasswordLessRequest
+} from './pkg/grpc/scalekit/v1/auth/passwordless_pb';
+
+export default class PasswordlessClient {
+  private client: PromiseClient<typeof PasswordlessService>;
+  constructor(
+    private readonly grpcConncet: GrpcConnect,
+    private readonly coreClient: CoreClient
+  ) {
+    this.client = this.grpcConncet.createClient(PasswordlessService);
+  }
+
+  /**
+   * Send a passwordless authentication email
+   * @param {string} email The email address to send the passwordless link to
+   * @param {object} options The options for sending the passwordless email
+   * @param {TemplateType} options.template The template type (SIGNIN/SIGNUP)
+   * @param {string} options.state Optional state parameter to maintain state between request and callback
+   * @param {string} options.magiclinkRedirectUri Optional redirect URI for magic link authentication
+   * @param {number} options.expiresIn Optional expiration time in seconds (default: 3600)
+   * @returns {Promise<SendPasswordlessResponse>} The response containing:
+   * - authRequestId: Unique identifier for the passwordless authentication request
+   * - expiresAt: Expiration time in seconds since epoch
+   * - expiresIn: Expiration time in seconds
+   * - passwordlessType: Type of passwordless authentication (OTP/LINK/LINK_OTP)
+   */
+  async sendPasswordlessEmail(
+    email: string,
+    options?: {
+      template?: TemplateType;
+      state?: string;
+      magiclinkRedirectUri?: string;
+      expiresIn?: number;
+    }
+  ): Promise<SendPasswordlessResponse> {
+    if (!email || typeof email !== 'string') {
+      throw new Error('Email must be a valid string');
+    }
+
+    let templateValue: TemplateType | undefined;
+    if (options?.template) {
+      if (typeof options.template === 'string') {
+        templateValue = TemplateType[options.template as keyof typeof TemplateType];
+        if (templateValue === undefined) {
+          throw new Error('Invalid template type');
+        }
+      } else {
+        templateValue = options.template;
+      }
+    }
+
+    if (options?.state && typeof options.state !== 'string') {
+      throw new Error('State must be a string');
+    }
+
+    if (options?.magiclinkRedirectUri && typeof options.magiclinkRedirectUri !== 'string') {
+      throw new Error('Magic link redirect URI must be a string');
+    }
+
+    const request: SendPasswordlessRequest = new SendPasswordlessRequest({
+      email,
+      template: templateValue,
+      state: options?.state,
+      magiclinkRedirectUri: options?.magiclinkRedirectUri,
+      expiresIn: options?.expiresIn
+    });
+
+    return this.coreClient.connectExec(
+      this.client.sendPasswordlessEmail,
+      request
+    );
+  }
+
+  /**
+   * Verify a passwordless authentication code or link token
+   * @param {string} authRequestId The auth request ID from the send response
+   * @param {object} credential The credential to verify
+   * @param {string} credential.code The one-time code received via email
+   * @param {string} credential.linkToken The link token received via email
+   * @returns {Promise<VerifyPasswordLessResponse>} The response containing:
+   * - email: The email address that was verified
+   * - state: Optional state parameter that was passed in the send request
+   * - template: The template type used for the authentication
+   * - passwordlessType: Type of passwordless authentication used
+   */
+  async verifyPasswordlessEmail(
+    authRequestId: string,
+    credential: { code?: string; linkToken?: string }
+  ): Promise<VerifyPasswordLessResponse> {
+    if (!credential.code && !credential.linkToken) {
+      throw new Error('Either code or linkToken must be provided');
+    }
+
+    const request = new VerifyPasswordLessRequest({
+      authRequestId,
+      authCredential: credential.code 
+        ? { case: "code", value: credential.code }
+        : { case: "linkToken", value: credential.linkToken! }
+    });
+
+    return this.coreClient.connectExec(
+      this.client.verifyPasswordlessEmail,
+      request
+    );
+  }
+
+  /**
+   * Resend a passwordless authentication email
+   * @param {string} authRequestId The auth request ID from the original send response
+   * @returns {Promise<SendPasswordlessResponse>} The response containing:
+   * - authRequestId: New unique identifier for the passwordless authentication request
+   * - expiresAt: New expiration time in seconds since epoch
+   * - expiresIn: New expiration time in seconds
+   * - passwordlessType: Type of passwordless authentication (OTP/LINK/LINK_OTP)
+   */
+  async resendPasswordlessEmail(
+    authRequestId: string
+  ): Promise<SendPasswordlessResponse> {
+    return this.coreClient.connectExec(
+      this.client.resendPasswordlessEmail,
+      {
+        authRequestId
+      }
+    );
+  }
+} 

package/src/pkg/grpc/scalekit/v1/auth/passwordless_connect.ts

@@ -0,0 +1,44 @@
+// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=ts"
+// @generated from file scalekit/v1/auth/passwordless.proto (package scalekit.v1.auth.passwordless, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { ResendPasswordlessRequest, SendPasswordlessRequest, SendPasswordlessResponse, VerifyPasswordLessRequest, VerifyPasswordLessResponse } from "./passwordless_pb.js";
+import { MethodKind } from "@bufbuild/protobuf";
+
+/**
+ * @generated from service scalekit.v1.auth.passwordless.PasswordlessService
+ */
+export const PasswordlessService = {
+  typeName: "scalekit.v1.auth.passwordless.PasswordlessService",
+  methods: {
+    /**
+     * @generated from rpc scalekit.v1.auth.passwordless.PasswordlessService.SendPasswordlessEmail
+     */
+    sendPasswordlessEmail: {
+      name: "SendPasswordlessEmail",
+      I: SendPasswordlessRequest,
+      O: SendPasswordlessResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.passwordless.PasswordlessService.VerifyPasswordlessEmail
+     */
+    verifyPasswordlessEmail: {
+      name: "VerifyPasswordlessEmail",
+      I: VerifyPasswordLessRequest,
+      O: VerifyPasswordLessResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.passwordless.PasswordlessService.ResendPasswordlessEmail
+     */
+    resendPasswordlessEmail: {
+      name: "ResendPasswordlessEmail",
+      I: ResendPasswordlessRequest,
+      O: SendPasswordlessResponse,
+      kind: MethodKind.Unary,
+    },
+  }
+} as const;
+

package/src/pkg/grpc/scalekit/v1/auth/passwordless_pb.ts

@@ -0,0 +1,330 @@
+// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
+// @generated from file scalekit/v1/auth/passwordless.proto (package scalekit.v1.auth.passwordless, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
+
+/**
+ * @generated from enum scalekit.v1.auth.passwordless.TemplateType
+ */
+export enum TemplateType {
+  /**
+   * @generated from enum value: UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: SIGNIN = 1;
+   */
+  SIGNIN = 1,
+
+  /**
+   * @generated from enum value: SIGNUP = 2;
+   */
+  SIGNUP = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(TemplateType)
+proto3.util.setEnumType(TemplateType, "scalekit.v1.auth.passwordless.TemplateType", [
+  { no: 0, name: "UNSPECIFIED" },
+  { no: 1, name: "SIGNIN" },
+  { no: 2, name: "SIGNUP" },
+]);
+
+/**
+ * @generated from enum scalekit.v1.auth.passwordless.PasswordlessType
+ */
+export enum PasswordlessType {
+  /**
+   * @generated from enum value: PASSWORDLESS_TYPE_UNSPECIFIED = 0;
+   */
+  PASSWORDLESS_TYPE_UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: OTP = 1;
+   */
+  OTP = 1,
+
+  /**
+   * @generated from enum value: LINK = 2;
+   */
+  LINK = 2,
+
+  /**
+   * @generated from enum value: LINK_OTP = 3;
+   */
+  LINK_OTP = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(PasswordlessType)
+proto3.util.setEnumType(PasswordlessType, "scalekit.v1.auth.passwordless.PasswordlessType", [
+  { no: 0, name: "PASSWORDLESS_TYPE_UNSPECIFIED" },
+  { no: 1, name: "OTP" },
+  { no: 2, name: "LINK" },
+  { no: 3, name: "LINK_OTP" },
+]);
+
+/**
+ * @generated from message scalekit.v1.auth.passwordless.SendPasswordlessRequest
+ */
+export class SendPasswordlessRequest extends Message<SendPasswordlessRequest> {
+  /**
+   * @generated from field: string email = 1;
+   */
+  email = "";
+
+  /**
+   * @generated from field: optional scalekit.v1.auth.passwordless.TemplateType template = 2;
+   */
+  template?: TemplateType;
+
+  /**
+   * @generated from field: optional string magiclink_redirect_uri = 3;
+   */
+  magiclinkRedirectUri?: string;
+
+  /**
+   * @generated from field: optional string state = 4;
+   */
+  state?: string;
+
+  /**
+   * @generated from field: optional uint32 expires_in = 5;
+   */
+  expiresIn?: number;
+
+  constructor(data?: PartialMessage<SendPasswordlessRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "scalekit.v1.auth.passwordless.SendPasswordlessRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "email", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "template", kind: "enum", T: proto3.getEnumType(TemplateType), opt: true },
+    { no: 3, name: "magiclink_redirect_uri", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 4, name: "state", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 5, name: "expires_in", kind: "scalar", T: 13 /* ScalarType.UINT32 */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendPasswordlessRequest {
+    return new SendPasswordlessRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendPasswordlessRequest {
+    return new SendPasswordlessRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendPasswordlessRequest {
+    return new SendPasswordlessRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendPasswordlessRequest | PlainMessage<SendPasswordlessRequest> | undefined, b: SendPasswordlessRequest | PlainMessage<SendPasswordlessRequest> | undefined): boolean {
+    return proto3.util.equals(SendPasswordlessRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message scalekit.v1.auth.passwordless.SendPasswordlessResponse
+ */
+export class SendPasswordlessResponse extends Message<SendPasswordlessResponse> {
+  /**
+   * @generated from field: string auth_request_id = 1;
+   */
+  authRequestId = "";
+
+  /**
+   * @generated from field: int64 expires_at = 2;
+   */
+  expiresAt = protoInt64.zero;
+
+  /**
+   * @generated from field: uint32 expires_in = 3;
+   */
+  expiresIn = 0;
+
+  /**
+   * @generated from field: scalekit.v1.auth.passwordless.PasswordlessType passwordless_type = 4;
+   */
+  passwordlessType = PasswordlessType.PASSWORDLESS_TYPE_UNSPECIFIED;
+
+  constructor(data?: PartialMessage<SendPasswordlessResponse>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "scalekit.v1.auth.passwordless.SendPasswordlessResponse";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "auth_request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "expires_at", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 3, name: "expires_in", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "passwordless_type", kind: "enum", T: proto3.getEnumType(PasswordlessType) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendPasswordlessResponse {
+    return new SendPasswordlessResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendPasswordlessResponse {
+    return new SendPasswordlessResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendPasswordlessResponse {
+    return new SendPasswordlessResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendPasswordlessResponse | PlainMessage<SendPasswordlessResponse> | undefined, b: SendPasswordlessResponse | PlainMessage<SendPasswordlessResponse> | undefined): boolean {
+    return proto3.util.equals(SendPasswordlessResponse, a, b);
+  }
+}
+
+/**
+ * @generated from message scalekit.v1.auth.passwordless.VerifyPasswordLessRequest
+ */
+export class VerifyPasswordLessRequest extends Message<VerifyPasswordLessRequest> {
+  /**
+   * @generated from oneof scalekit.v1.auth.passwordless.VerifyPasswordLessRequest.auth_credential
+   */
+  authCredential: {
+    /**
+     * @generated from field: string code = 1;
+     */
+    value: string;
+    case: "code";
+  } | {
+    /**
+     * @generated from field: string link_token = 2;
+     */
+    value: string;
+    case: "linkToken";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  /**
+   * @generated from field: string auth_request_id = 3;
+   */
+  authRequestId = "";
+
+  constructor(data?: PartialMessage<VerifyPasswordLessRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "scalekit.v1.auth.passwordless.VerifyPasswordLessRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "code", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "auth_credential" },
+    { no: 2, name: "link_token", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "auth_credential" },
+    { no: 3, name: "auth_request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VerifyPasswordLessRequest {
+    return new VerifyPasswordLessRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VerifyPasswordLessRequest {
+    return new VerifyPasswordLessRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VerifyPasswordLessRequest {
+    return new VerifyPasswordLessRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: VerifyPasswordLessRequest | PlainMessage<VerifyPasswordLessRequest> | undefined, b: VerifyPasswordLessRequest | PlainMessage<VerifyPasswordLessRequest> | undefined): boolean {
+    return proto3.util.equals(VerifyPasswordLessRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message scalekit.v1.auth.passwordless.ResendPasswordlessRequest
+ */
+export class ResendPasswordlessRequest extends Message<ResendPasswordlessRequest> {
+  /**
+   * @generated from field: string auth_request_id = 1;
+   */
+  authRequestId = "";
+
+  constructor(data?: PartialMessage<ResendPasswordlessRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "scalekit.v1.auth.passwordless.ResendPasswordlessRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "auth_request_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResendPasswordlessRequest {
+    return new ResendPasswordlessRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResendPasswordlessRequest {
+    return new ResendPasswordlessRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResendPasswordlessRequest {
+    return new ResendPasswordlessRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ResendPasswordlessRequest | PlainMessage<ResendPasswordlessRequest> | undefined, b: ResendPasswordlessRequest | PlainMessage<ResendPasswordlessRequest> | undefined): boolean {
+    return proto3.util.equals(ResendPasswordlessRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message scalekit.v1.auth.passwordless.VerifyPasswordLessResponse
+ */
+export class VerifyPasswordLessResponse extends Message<VerifyPasswordLessResponse> {
+  /**
+   * @generated from field: string email = 1;
+   */
+  email = "";
+
+  /**
+   * @generated from field: optional string state = 2;
+   */
+  state?: string;
+
+  /**
+   * @generated from field: optional scalekit.v1.auth.passwordless.TemplateType template = 3;
+   */
+  template?: TemplateType;
+
+  /**
+   * @generated from field: scalekit.v1.auth.passwordless.PasswordlessType passwordless_type = 4;
+   */
+  passwordlessType = PasswordlessType.PASSWORDLESS_TYPE_UNSPECIFIED;
+
+  constructor(data?: PartialMessage<VerifyPasswordLessResponse>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "scalekit.v1.auth.passwordless.VerifyPasswordLessResponse";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "email", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "state", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "template", kind: "enum", T: proto3.getEnumType(TemplateType), opt: true },
+    { no: 4, name: "passwordless_type", kind: "enum", T: proto3.getEnumType(PasswordlessType) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VerifyPasswordLessResponse {
+    return new VerifyPasswordLessResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VerifyPasswordLessResponse {
+    return new VerifyPasswordLessResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VerifyPasswordLessResponse {
+    return new VerifyPasswordLessResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: VerifyPasswordLessResponse | PlainMessage<VerifyPasswordLessResponse> | undefined, b: VerifyPasswordLessResponse | PlainMessage<VerifyPasswordLessResponse> | undefined): boolean {
+    return proto3.util.equals(VerifyPasswordLessResponse, a, b);
+  }
+}
+

package/src/pkg/grpc/scalekit/v1/connections/connections_connect.ts

@@ -3,7 +3,7 @@
 /* eslint-disable */
 // @ts-nocheck
 
-import { CreateConnectionRequest, CreateConnectionResponse, CreateEnvironmentConnectionRequest, DeleteConnectionRequest, DeleteEnvironmentConnectionRequest, GetConnectionRequest, GetConnectionResponse, GetEnvironmentConnectionRequest, GetProvidersRequest, GetProvidersResponse, ListConnectionsRequest, ListConnectionsResponse, ToggleConnectionRequest, ToggleConnectionResponse, ToggleEnvironmentConnectionRequest, UpdateConnectionRequest, UpdateConnectionResponse, UpdateEnvironmentConnectionRequest } from "./connections_pb.js";
+import { CreateConnectionRequest, CreateConnectionResponse, CreateEnvironmentConnectionRequest, DeleteConnectionRequest, DeleteEnvironmentConnectionRequest, GetConnectionRequest, GetConnectionResponse, GetConnectionTestResultRequest, GetConnectionTestResultResponse, GetEnvironmentConnectionRequest, GetProvidersRequest, GetProvidersResponse, ListConnectionsRequest, ListConnectionsResponse, ToggleConnectionRequest, ToggleConnectionResponse, ToggleEnvironmentConnectionRequest, UpdateConnectionRequest, UpdateConnectionResponse, UpdateEnvironmentConnectionRequest } from "./connections_pb.js";
 import { Empty, MethodKind } from "@bufbuild/protobuf";
 
 /**
@@ -138,6 +138,15 @@ export const ConnectionService = {
       O: ToggleConnectionResponse,
       kind: MethodKind.Unary,
     },
+    /**
+     * @generated from rpc scalekit.v1.connections.ConnectionService.GetConnectionTestResult
+     */
+    getConnectionTestResult: {
+      name: "GetConnectionTestResult",
+      I: GetConnectionTestResultRequest,
+      O: GetConnectionTestResultResponse,
+      kind: MethodKind.Unary,
+    },
   }
 } as const;