@akanjs/nest 0.0.39 → 0.0.41

package/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/nest",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"

package/src/authGuards.d.ts

@@ -0,0 +1,51 @@
+import type { Account as SerAccount } from "@akanjs/signal";
+import { CanActivate, ExecutionContext } from "@nestjs/common";
+import type { Socket } from "socket.io";
+export interface RequestContext {
+    account: SerAccount;
+    ip?: string;
+    userAgent?: string;
+    geolocation?: string;
+    headers: Record<string, string | undefined>;
+    cookies?: Record<string, string>;
+}
+export interface ReqType {
+    method: string;
+    url: string;
+    params: object;
+    query: object;
+    body: object;
+}
+export interface GqlReqType {
+    parentType?: {
+        name?: string;
+    };
+    fieldName?: string;
+}
+export declare const getRequest: (context: ExecutionContext) => unknown;
+export declare const getResponse: (context: ExecutionContext) => unknown;
+export declare const getArgs: (context: ExecutionContext) => {
+    [key: string]: any;
+};
+export declare const getSocket: (context: ExecutionContext) => Socket<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>;
+export declare class Public implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class None implements CanActivate {
+    canActivate(): boolean;
+}
+export declare class Every implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class Owner implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class Admin implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class SuperAdmin implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class User implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}

package/src/authentication.d.ts

@@ -0,0 +1,18 @@
+export declare const Account: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Self: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Me: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const UserIp: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Access: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Req: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export declare const Res: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export declare const Ws: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/src/authorization.d.ts

@@ -0,0 +1,3 @@
+import { Account } from "@akanjs/signal";
+export declare const verifyToken: (secret: string, authorization: string | undefined) => Account;
+export declare const allow: (account: Account | null, roles: ("user" | "admin" | "superAdmin")[], userId?: string) => boolean;

package/src/cacheClient.d.ts

@@ -0,0 +1,4 @@
+import type { RedisClientType } from "redis";
+export declare class CacheClient {
+    redis: RedisClientType;
+}

package/src/databaseClient.d.ts

@@ -0,0 +1,5 @@
+import type { Connection } from "mongoose";
+export declare class DatabaseClient {
+    connection: Connection;
+    getModel(modelName: string): import("mongoose").Model<any, {}, {}, {}, any, any>;
+}

package/src/decorators.d.ts

@@ -0,0 +1,13 @@
+import "reflect-metadata";
+import { CronExpression } from "@nestjs/schedule";
+export declare const Try: () => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+interface TimerOptions {
+    lock?: boolean;
+    serverMode?: "federation" | "batch";
+    enabled?: boolean;
+}
+export declare const Cron: (cronTime: CronExpression | string, { lock, serverMode, enabled }?: TimerOptions) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Interval: (ms: number, { lock, serverMode, enabled }?: TimerOptions) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor | undefined;
+export declare const Transaction: () => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Cache: (timeout?: number, getCacheKey?: (...args: any) => string) => MethodDecorator;
+export {};

package/src/exceptions.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+export declare class AllExceptionsFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(exception: Error, host: ArgumentsHost): void;
+}

package/src/exporter.d.ts

@@ -0,0 +1,22 @@
+import * as fs from "fs";
+export declare const objPath: (o: unknown, p: string) => unknown;
+export declare class FileSystem {
+    filename: string;
+    dirname: string;
+    writeStream?: fs.WriteStream;
+    constructor(dirname?: string, filename?: string);
+    init(): Promise<unknown>;
+    write(body: string): boolean;
+}
+export interface ExportForm<T> {
+    items: T[];
+    path: string;
+    fields?: string[];
+    options?: {
+        append: boolean;
+    };
+    delimiter?: string;
+}
+export declare const exportToCsv: <T>({ items, path, fields, delimiter, options }: ExportForm<T>) => Promise<void>;
+export declare const exportToJson: <T>(items: T | T[], localPath: string) => void;
+export declare const readJson: (localPath: string) => unknown;

package/src/generateSecrets.d.ts

@@ -0,0 +1,36 @@
+import { BackendEnv, type BaseEnv } from "@akanjs/base";
+import { SshOptions } from "tunnel-ssh";
+export declare const generateJwtSecret: (appName: string, environment: "debug" | "develop" | "main" | "testing") => string;
+export declare const generateAeskey: (appName: string, environment: "debug" | "develop" | "main" | "testing") => string;
+interface RedisEnv {
+    appName: string;
+    appCode: number;
+    environment: BaseEnv["environment"];
+    operationMode: BaseEnv["operationMode"];
+    sshOptions?: SshOptions;
+}
+export declare const generateRedisUri: ({ appName, appCode, environment, operationMode, sshOptions }: RedisEnv) => Promise<string>;
+interface MongoEnv {
+    appName: string;
+    appCode: number;
+    environment: BaseEnv["environment"];
+    operationMode: BaseEnv["operationMode"];
+    username?: string;
+    password?: string;
+    sshOptions?: SshOptions;
+}
+export declare const generateMongoUri: ({ appName, appCode, environment, operationMode, username, password, sshOptions, }: MongoEnv) => Promise<string>;
+interface MeiliEnv {
+    appName: string;
+    appCode: number;
+    environment: BaseEnv["environment"];
+    operationMode: BaseEnv["operationMode"];
+}
+export declare const generateMeiliUri: ({ appName, appCode, environment, operationMode }: MeiliEnv) => string;
+export declare const SALT_ROUNDS = 11;
+export declare const generateHost: (env: BackendEnv) => string;
+export declare const generateMeiliKey: ({ appName, environment }: {
+    appName: string;
+    environment: string;
+}) => string;
+export {};

package/src/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./authorization";
+export * from "./authGuards";
+export * as guards from "./authGuards";
+export * from "./authentication";
+export * from "./interceptors";
+export * from "./redis-io.adapter";
+export * from "./pipes";
+export * as Exporter from "./exporter";
+export * from "./exporter";
+export * from "./verifyPayment";
+export * from "./sso";
+export * from "./exceptions";
+export * from "./generateSecrets";
+export * from "./mongoose";
+export * from "./searchClient";
+export * from "./cacheClient";
+export * from "./databaseClient";
+export * from "./decorators";

package/src/interceptors.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from "@akanjs/common";
+import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
+import type { RedisClientType } from "redis";
+import { Observable } from "rxjs";
+export declare class CacheInterceptor implements NestInterceptor {
+    #private;
+    private readonly redis;
+    constructor(redis: RedisClientType<any, any, any>);
+    intercept<T>(context: ExecutionContext, next: CallHandler): Promise<Observable<T>>;
+}
+export declare class TimeoutInterceptor implements NestInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+export declare class LoggingInterceptor implements NestInterceptor {
+    logger: Logger;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}

package/src/mongoose.d.ts

@@ -0,0 +1,5 @@
+export declare const initMongoDB: ({ logging, threshold, sendReport, }: {
+    logging: boolean;
+    threshold?: number;
+    sendReport?: boolean;
+}) => void;

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/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/searchClient.d.ts

@@ -0,0 +1,28 @@
+import { type TextDoc } from "@akanjs/constant";
+import { default as MeiliSearch } from "meilisearch";
+export declare class SearchClient {
+    meili: MeiliSearch;
+    getIndexNames(): Promise<string[]>;
+    getSearchResult(indexName: string, option: {
+        skip?: number;
+        limit?: number;
+        sort?: string;
+        searchString?: string;
+    }): Promise<{
+        docs: Record<string, any>[];
+        skip: number;
+        limit: number;
+        sort: string;
+        total: number;
+        query?: undefined;
+    } | {
+        docs: import("meilisearch").Hits<Record<string, any>>;
+        skip: number;
+        limit: number;
+        sort: string;
+        total: number;
+        query: string;
+    }>;
+    upsertDocuments(indexName: string, documents: TextDoc[]): Promise<import("meilisearch").EnqueuedTask>;
+    dropIndex(indexName: string): Promise<import("meilisearch").EnqueuedTask>;
+}

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/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 {};