@akanjs/nest 0.0.4

package/src/mongoose.js

@@ -0,0 +1,93 @@
+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 __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);
+var mongoose_exports = {};
+__export(mongoose_exports, {
+  initMongoDB: () => initMongoDB
+});
+module.exports = __toCommonJS(mongoose_exports);
+var import_common = require("@akanjs/common");
+var import_mongoose = __toESM(require("mongoose"));
+const initMongoDB = ({
+  logging,
+  threshold = 5e3,
+  sendReport = false
+}) => {
+  const mongoDBLogger = new import_common.Logger("MongoDB");
+  if (logging)
+    import_mongoose.default.set("debug", function(collection, method, ...methodArgs) {
+      mongoDBLogger.verbose(
+        `${collection}.${method}(${methodArgs.slice(0, -1).map((arg) => JSON.stringify(arg)).join(", ")})`
+      );
+    });
+  const originalExec = import_mongoose.default.Query.prototype.exec;
+  const getQueryInfo = (queryAgent) => {
+    const model = queryAgent.model;
+    const collectionName = model.collection.collectionName;
+    const dbName = model.db.name;
+    const query = queryAgent.getQuery();
+    const queryOptions = queryAgent.getOptions();
+    return { dbName, collectionName, query, queryOptions };
+  };
+  import_mongoose.default.Query.prototype.exec = function(...args) {
+    const start = Date.now();
+    return originalExec.apply(this, args).then((result) => {
+      const duration = Date.now() - start;
+      const { dbName, collectionName, query, queryOptions } = getQueryInfo(this);
+      if (logging)
+        mongoDBLogger.verbose(
+          `Queried ${dbName}.${collectionName}.query(${JSON.stringify(query)}, ${JSON.stringify(
+            queryOptions
+          )}) - ${duration}ms`
+        );
+      return result;
+    });
+  };
+  const originalAggregate = import_mongoose.default.Model.aggregate;
+  const getAggregateInfo = (aggregateModel) => {
+    const dbName = aggregateModel.db.db?.databaseName ?? "unknown";
+    const collectionName = aggregateModel.collection.collectionName;
+    return { dbName, collectionName };
+  };
+  import_mongoose.default.Model.aggregate = function(...args) {
+    const startTime = Date.now();
+    return originalAggregate.apply(this, args).then((result) => {
+      const duration = Date.now() - startTime;
+      const { dbName, collectionName } = getAggregateInfo(this);
+      if (logging)
+        mongoDBLogger.verbose(
+          `Aggregated ${dbName}.${collectionName}.aggregate(${args.map((arg) => JSON.stringify(arg)).join(", ")}) - ${duration}ms`
+        );
+      return result;
+    });
+  };
+  import_mongoose.default.set("transactionAsyncLocalStorage", true);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initMongoDB
+});

package/src/pipes.d.ts

@@ -0,0 +1,48 @@
+import { Type } from "@akanjs/base";
+import { ArgMeta } from "@akanjs/signal";
+import { ArgumentMetadata, PipeTransform } from "@nestjs/common";
+import { Readable } from "stream";
+export declare class ArrayifyPipe implements PipeTransform {
+    transform(value: string | string[], metadata: ArgumentMetadata): string[];
+}
+export declare class IntPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): number[];
+}
+export declare class FloatPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): number[];
+}
+export declare class BooleanPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): boolean[];
+}
+export declare class DayjsPipe implements PipeTransform {
+    transform(value: string, metadata: ArgumentMetadata): import("dayjs").Dayjs[];
+}
+export declare class JSONPipe implements PipeTransform {
+    transform(value: string | object, metadata: ArgumentMetadata): object;
+}
+interface FileStream {
+    originalname: string;
+    mimetype: string;
+    encoding: string;
+    buffer: Buffer;
+}
+export declare class MulterToUploadPipe implements PipeTransform {
+    transform(value: FileStream, metadata: ArgumentMetadata): {
+        filename: string;
+        mimetype: string;
+        encoding: string;
+        createReadStream: () => Readable;
+    } | {
+        filename: string;
+        mimetype: string;
+        encoding: string;
+        createReadStream: () => Readable;
+    }[];
+}
+export declare const getQueryPipes: (modelRef: Type, arrDepth: number) => Type[];
+export declare const getBodyPipes: (argMeta: ArgMeta) => {
+    new (): {
+        transform(value: any, metadata: ArgumentMetadata): object[] | null;
+    };
+}[];
+export {};

package/src/pipes.js

@@ -0,0 +1,147 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var pipes_exports = {};
+__export(pipes_exports, {
+  ArrayifyPipe: () => ArrayifyPipe,
+  BooleanPipe: () => BooleanPipe,
+  DayjsPipe: () => DayjsPipe,
+  FloatPipe: () => FloatPipe,
+  IntPipe: () => IntPipe,
+  JSONPipe: () => JSONPipe,
+  MulterToUploadPipe: () => MulterToUploadPipe,
+  getBodyPipes: () => getBodyPipes,
+  getQueryPipes: () => getQueryPipes
+});
+module.exports = __toCommonJS(pipes_exports);
+var import_base = require("@akanjs/base");
+var import_signal = require("@akanjs/signal");
+var import_common = require("@nestjs/common");
+var import_stream = require("stream");
+let ArrayifyPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value : value.split(",");
+  }
+};
+ArrayifyPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], ArrayifyPipe);
+let IntPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(parseInt) : [parseInt(value)];
+  }
+};
+IntPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], IntPipe);
+let FloatPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(parseFloat) : [parseFloat(value)];
+  }
+};
+FloatPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], FloatPipe);
+let BooleanPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map((v) => Boolean(v)) : [Boolean(value)];
+  }
+};
+BooleanPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], BooleanPipe);
+let DayjsPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(import_base.dayjs) : [(0, import_base.dayjs)(value)];
+  }
+};
+DayjsPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], DayjsPipe);
+let JSONPipe = class {
+  transform(value, metadata) {
+    const transformable = typeof value === "string" && value.length;
+    const obj = transformable ? JSON.parse(atob(value)) : value;
+    return obj;
+  }
+};
+JSONPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], JSONPipe);
+const convertToFileStream = (value) => ({
+  filename: value.originalname,
+  mimetype: value.mimetype,
+  encoding: value.encoding,
+  createReadStream: () => import_stream.Readable.from(value.buffer)
+});
+let MulterToUploadPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(convertToFileStream) : convertToFileStream(value);
+  }
+};
+MulterToUploadPipe = __decorateClass([
+  (0, import_common.Injectable)()
+], MulterToUploadPipe);
+const gqlScalarPipeMap = /* @__PURE__ */ new Map([
+  [import_base.Int, IntPipe],
+  [import_base.Float, FloatPipe],
+  [Boolean, BooleanPipe],
+  [Date, DayjsPipe],
+  [import_base.JSON, JSONPipe]
+]);
+const getQueryPipes = (modelRef, arrDepth) => {
+  const pipes = arrDepth ? [ArrayifyPipe] : [];
+  const scalarPipe = gqlScalarPipeMap.get(modelRef);
+  if (scalarPipe)
+    pipes.push(scalarPipe);
+  return pipes;
+};
+const getBodyPipes = (argMeta) => {
+  const [returnRef] = (0, import_base.getNonArrayModel)(argMeta.returns());
+  if (returnRef.prototype !== Date.prototype && !(0, import_base.isGqlScalar)(returnRef))
+    return [];
+  let BodyPipe = class {
+    transform(value, metadata) {
+      return (0, import_signal.deserializeArg)(argMeta, value);
+    }
+  };
+  BodyPipe = __decorateClass([
+    (0, import_common.Injectable)()
+  ], BodyPipe);
+  return [BodyPipe];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayifyPipe,
+  BooleanPipe,
+  DayjsPipe,
+  FloatPipe,
+  IntPipe,
+  JSONPipe,
+  MulterToUploadPipe,
+  getBodyPipes,
+  getQueryPipes
+});

package/src/redis-io.adapter.d.ts

@@ -0,0 +1,19 @@
+import { INestApplicationContext } from "@nestjs/common";
+import { IoAdapter } from "@nestjs/platform-socket.io";
+import { ServerOptions } from "socket.io";
+interface RedisIoAdapterOption extends Partial<ServerOptions> {
+    jwtSecret: string;
+}
+export declare class RedisIoAdapter extends IoAdapter {
+    private adapterConstructor;
+    private readonly logger;
+    private server;
+    private pubClient;
+    private subClient;
+    option: RedisIoAdapterOption;
+    constructor(appOrHttpServer: INestApplicationContext, option: RedisIoAdapterOption);
+    connectToRedis(url: string): Promise<void>;
+    createIOServer(port: number, options?: ServerOptions): any;
+    destroy(): Promise<void>;
+}
+export {};

package/src/redis-io.adapter.js

@@ -0,0 +1,84 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redis_io_adapter_exports = {};
+__export(redis_io_adapter_exports, {
+  RedisIoAdapter: () => RedisIoAdapter
+});
+module.exports = __toCommonJS(redis_io_adapter_exports);
+var import_common = require("@akanjs/common");
+var import_platform_socket = require("@nestjs/platform-socket.io");
+var import_redis_adapter = require("@socket.io/redis-adapter");
+var import_redis = require("redis");
+class RedisIoAdapter extends import_platform_socket.IoAdapter {
+  adapterConstructor;
+  logger = new import_common.Logger("RedisIoAdapter");
+  server;
+  pubClient;
+  subClient;
+  option;
+  constructor(appOrHttpServer, option) {
+    super(appOrHttpServer);
+    this.option = option;
+  }
+  async connectToRedis(url) {
+    this.pubClient = (0, import_redis.createClient)({ url });
+    this.subClient = this.pubClient.duplicate();
+    this.pubClient.on("disconnect", (err) => {
+      this.logger.error(`Redis pub database is disconnected. Error: ${err}`);
+      void this.pubClient.connect();
+    });
+    this.subClient.on("disconnect", (err) => {
+      this.logger.error(`Redis sub database is disconnected. Error: ${err}`);
+      void this.subClient.connect();
+    });
+    this.pubClient.on("error", (err) => {
+      this.logger.error(`Redis pub database is errored. Error: ${err}`);
+      const reconnect = async () => {
+        await this.pubClient.quit();
+        await (0, import_common.sleep)(1e3);
+        await this.pubClient.connect();
+      };
+      void reconnect();
+    });
+    this.subClient.on("error", (err) => {
+      this.logger.error(`Redis sub database is errored. Error: ${err}`);
+      const reconnect = async () => {
+        await this.subClient.quit();
+        await (0, import_common.sleep)(1e3);
+        await this.subClient.connect();
+      };
+      void reconnect();
+    });
+    await Promise.all([this.pubClient.connect(), this.subClient.connect()]);
+    this.adapterConstructor = (0, import_redis_adapter.createAdapter)(this.pubClient, this.subClient);
+  }
+  createIOServer(port, options) {
+    this.server = super.createIOServer(port, options);
+    this.server.adapter(this.adapterConstructor);
+    return this.server;
+  }
+  async destroy() {
+    await Promise.all([this.pubClient.quit(), this.subClient.quit()]);
+    await this.close(this.server);
+    this.logger.log("RedisIoAdapter is closed");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisIoAdapter
+});

package/src/sso.d.ts

@@ -0,0 +1,75 @@
+import type { Type } from "@akanjs/base";
+import type { SSOType } from "@akanjs/signal";
+import * as jwt from "jsonwebtoken";
+export interface SSOCredential {
+    clientID: string;
+    clientSecret?: string;
+}
+export type AppleCredential = SSOCredential & {
+    teamID: string;
+    keyID: string;
+    keyFilePath: string;
+};
+export type SSOOptions = {
+    [key in SSOType]?: SSOCredential | AppleCredential;
+};
+export declare const getSsoProviders: (host: string, ssoOptions: SSOOptions) => Type[];
+export interface KakaoResponse {
+    name?: string;
+    email: string;
+}
+export interface NaverResponse {
+    name?: string;
+    email: string;
+}
+export interface GithubResponse {
+    id: string;
+    displayName: string;
+    username: string;
+    profileUrl: string;
+    photos: {
+        value: string;
+    }[];
+}
+export interface GoogleResponse {
+    id: string;
+    displayName: string;
+    name: {
+        familyName: string;
+        givenName: string;
+    };
+    emails: {
+        value: string;
+        verified: boolean;
+    }[];
+    photos: {
+        value: string;
+    }[];
+}
+export interface FacebookResponse {
+    id: string;
+    name: {
+        familyName: string;
+        givenName: string;
+    };
+    emails: {
+        value: string;
+        verified: boolean;
+    }[];
+}
+export interface SsoCookie {
+    prepareUserId?: string;
+    ssoFor: "user" | "admin";
+    signinRedirect: string;
+    signupRedirect: string;
+    adminRedirect?: string;
+    errorRedirect?: string;
+}
+export declare const verifyAppleUser: (payload: {
+    code: string;
+}, origin: string, sso: AppleCredential) => Promise<{
+    tokens: {
+        id_token?: string;
+    };
+    data: string | jwt.JwtPayload | null;
+}>;

package/src/sso.js

@@ -0,0 +1,187 @@
+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 __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);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var sso_exports = {};
+__export(sso_exports, {
+  getSsoProviders: () => getSsoProviders,
+  verifyAppleUser: () => verifyAppleUser
+});
+module.exports = __toCommonJS(sso_exports);
+var import_common = require("@nestjs/common");
+var import_passport = require("@nestjs/passport");
+var appleSignin = __toESM(require("apple-signin"));
+var jwt = __toESM(require("jsonwebtoken"));
+var import_passport_apple = require("passport-apple");
+var import_passport_facebook = require("passport-facebook");
+var import_passport_github = require("passport-github");
+var import_passport_google_oauth20 = require("passport-google-oauth20");
+var import_passport_kakao = require("passport-kakao");
+var import_passport_naver = require("passport-naver");
+const getSsoProviders = (host, ssoOptions) => {
+  const origin = host === "localhost" ? "http://localhost:8080/backend" : `https://${host}/backend`;
+  const providers = [];
+  if (ssoOptions.kakao) {
+    let KakaoOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_kakao.Strategy, "kakao") {
+      constructor() {
+        super({
+          ...ssoOptions.kakao,
+          callbackURL: `${origin}/user/kakao/callback`,
+          scope: ["account_email", "profile_nickname"]
+        });
+      }
+      validate(jwt2, refreshToken, profile) {
+        return {
+          name: profile.displayName,
+          email: profile._json.kakao_account.email,
+          password: profile.id
+        };
+      }
+    };
+    KakaoOauthStrategy = __decorateClass([
+      (0, import_common.Injectable)()
+    ], KakaoOauthStrategy);
+    providers.push(KakaoOauthStrategy);
+  }
+  if (ssoOptions.naver) {
+    let NaverOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_naver.Strategy, "naver") {
+      constructor() {
+        super({ ...ssoOptions.naver, callbackURL: `${origin}/user/naver/callback` });
+      }
+      validate(jwt2, refreshToken, profile) {
+        return {
+          name: profile.displayName,
+          email: profile._json.email,
+          password: profile.id
+        };
+      }
+    };
+    NaverOauthStrategy = __decorateClass([
+      (0, import_common.Injectable)()
+    ], NaverOauthStrategy);
+    providers.push(NaverOauthStrategy);
+  }
+  if (ssoOptions.github) {
+    let GithubOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_github.Strategy, "github") {
+      constructor() {
+        super({ ...ssoOptions.github, callbackURL: `${origin}/user/github/callback`, scope: ["user"] });
+      }
+      validate(accessToken, _refreshToken, profile) {
+        return profile;
+      }
+    };
+    GithubOauthStrategy = __decorateClass([
+      (0, import_common.Injectable)()
+    ], GithubOauthStrategy);
+    providers.push(GithubOauthStrategy);
+  }
+  if (ssoOptions.google) {
+    let GoogleOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_google_oauth20.Strategy, "google") {
+      constructor() {
+        super({ ...ssoOptions.google, callbackURL: `${origin}/user/google/callback`, scope: ["email", "profile"] });
+      }
+      validate(_accessToken, _refreshToken, profile) {
+        return profile;
+      }
+    };
+    GoogleOauthStrategy = __decorateClass([
+      (0, import_common.Injectable)()
+    ], GoogleOauthStrategy);
+    providers.push(GoogleOauthStrategy);
+  }
+  if (ssoOptions.facebook) {
+    let FacebookOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_facebook.Strategy, "facebook") {
+      constructor() {
+        super({
+          ...ssoOptions.facebook,
+          callbackURL: `${origin}/user/facebook/callback`,
+          scope: ["email"],
+          profileFields: ["emails", "name"]
+        });
+      }
+      validate(_accessToken, _refreshToken, profile) {
+        return profile;
+      }
+    };
+    FacebookOauthStrategy = __decorateClass([
+      (0, import_common.Injectable)()
+    ], FacebookOauthStrategy);
+    providers.push(FacebookOauthStrategy);
+  }
+  if (ssoOptions.apple) {
+    let AppleOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_apple.Strategy, "apple") {
+      constructor() {
+        super({
+          ...ssoOptions.apple,
+          callbackURL: `${origin}/user/apple/callback`,
+          passReqToCallback: true,
+          scope: ["name", "email"]
+        });
+      }
+      validate(req, accessToken, refreshToken, idToken, profile, cb) {
+        cb(null, idToken);
+      }
+    };
+    AppleOauthStrategy = __decorateClass([
+      (0, import_common.Injectable)()
+    ], AppleOauthStrategy);
+    providers.push(AppleOauthStrategy);
+  }
+  return providers;
+};
+const verifyAppleUser = async (payload, origin, sso) => {
+  const signinAgent = appleSignin;
+  const clientSecret = signinAgent.getClientSecret({
+    clientID: sso.clientID,
+    teamId: sso.teamID,
+    keyIdentifier: sso.keyID,
+    privateKeyPath: sso.keyFilePath
+  });
+  const tokens = await signinAgent.getAuthorizationToken(payload.code, {
+    clientID: sso.clientID,
+    clientSecret,
+    redirectUri: `${origin}/user/apple/callback`
+  });
+  if (!tokens.id_token) {
+    throw new Error("No id_token found in Apple's response");
+  }
+  const data = jwt.decode(tokens.id_token);
+  return { tokens, data };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSsoProviders,
+  verifyAppleUser
+});

package/src/verifyPayment.d.ts

@@ -0,0 +1,11 @@
+interface VerifyPaymentType {
+    packageName: string;
+    platform: string;
+    productId: string;
+    receipt: string;
+    secret?: string;
+    subscription?: boolean;
+    keyObject?: any;
+}
+export declare const verifyPayment: (payment: VerifyPaymentType) => Promise<unknown>;
+export {};