@xxmachina/common 19.0.0-preview.9 → 19.1.0

package/_shared/auth/index.d.ts

@@ -1 +1,8 @@
-export * from './auth.module';
+declare class AuthModule {
+    static forRoot(): {
+        module: typeof AuthModule;
+        providers: any[];
+    };
+}
+
+export { AuthModule };

package/_shared/auth/passports/anonymous/index.d.ts

@@ -1 +1,8 @@
-export * from './anonymous.strategy';
+import { Strategy } from 'passport-custom';
+
+declare const AnonymousStrategy_base: new (...args: any[]) => Strategy;
+declare class AnonymousStrategy extends AnonymousStrategy_base {
+    validate(request: Request): Promise<any>;
+}
+
+export { AnonymousStrategy };

package/_shared/auth/passports/firebase/index.d.ts

@@ -1,2 +1,19 @@
-export * from './firebase.guard';
-export * from './firebase.strategy';
+import * as _nestjs_passport from '@nestjs/passport';
+import { ExecutionContext } from '@nestjs/common';
+import { FirebaseAuthStrategy } from '@tfarras/nestjs-firebase-auth';
+import { Request } from 'express';
+import { ParamsDictionary } from 'express-serve-static-core';
+import { ParsedQs } from 'qs';
+
+declare const FirebaseAuthGuard_base: _nestjs_passport.Type<_nestjs_passport.IAuthGuard>;
+declare class FirebaseAuthGuard extends FirebaseAuthGuard_base {
+    getRequest(context: ExecutionContext): any;
+}
+
+declare const FirebaseStrategy_base: new (...args: any[]) => FirebaseAuthStrategy;
+declare class FirebaseStrategy extends FirebaseStrategy_base {
+    constructor();
+    authenticate(req: Request<ParamsDictionary, any, any, ParsedQs, Record<string, any>>): void;
+}
+
+export { FirebaseAuthGuard, FirebaseStrategy };

package/_shared/auth/passports/internal/index.d.ts

@@ -1 +1,17 @@
-export * from './internal.strategy';
+import * as passport_http_bearer from 'passport-http-bearer';
+import { Strategy } from 'passport-http-bearer';
+import { InjectionToken } from '@nestjs/common';
+
+declare const INTERNAL_STRATEGY_TOKEN: InjectionToken;
+declare function provideInternalStrategyToken(token: string): {
+    provide: InjectionToken;
+    useValue: string;
+};
+declare const InternalStrategy_base: new (...args: any[]) => Strategy<passport_http_bearer.VerifyFunctions>;
+declare class InternalStrategy extends InternalStrategy_base {
+    private token;
+    constructor(token: string);
+    validate(token: string): Promise<boolean>;
+}
+
+export { INTERNAL_STRATEGY_TOKEN, InternalStrategy, provideInternalStrategyToken };

package/_shared/auth/passports/msal/index.d.ts

@@ -1,2 +1,26 @@
-export * from './msal.guard';
-export * from './msal.strategy';
+import * as _nestjs_passport from '@nestjs/passport';
+import * as jsonwebtoken from 'jsonwebtoken';
+import { Provider } from '@nestjs/common';
+import { Strategy } from 'passport-custom';
+
+declare const MsalAuthGuard_base: _nestjs_passport.Type<_nestjs_passport.IAuthGuard>;
+declare class MsalAuthGuard extends MsalAuthGuard_base {
+}
+
+declare const MSAL_CONFIG = "MSAL_CONFIG";
+interface MsalConfig {
+    tenantId: string;
+    audience: string;
+    applicationId: string;
+    scopes: string[];
+}
+declare function provideMsalAuth(useFactory: () => MsalConfig): Provider[];
+declare const MsalStrategy_base: new (...args: any[]) => Strategy;
+declare class MsalStrategy extends MsalStrategy_base {
+    private readonly config;
+    constructor(config: MsalConfig);
+    validate(req: any): Promise<string | jsonwebtoken.JwtPayload>;
+}
+
+export { MSAL_CONFIG, MsalAuthGuard, MsalStrategy, provideMsalAuth };
+export type { MsalConfig };

package/_shared/meta/index.d.ts

@@ -0,0 +1,8 @@
+import decorators from '@nestjs/graphql';
+
+declare let ObjectType: any;
+declare let Field: any;
+declare let ID: any;
+declare function provideNestjsGraphql(_decorators: typeof decorators): void;
+
+export { Field, ID, ObjectType, provideNestjsGraphql };

package/_shared/meta/redis/index.d.ts

@@ -1,2 +1,39 @@
-export * from './redis.config';
-export * from './redis.repository';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { RedisClientType } from 'redis';
+
+interface RedisConfig {
+    url: string;
+}
+declare const REDIS_CONFIG: InjectionToken<RedisConfig>;
+declare function provideRedisConfig(config: RedisConfig): {
+    provide: InjectionToken<RedisConfig>;
+    useValue: RedisConfig;
+};
+
+declare class Converter<E, R> {
+    fromRedis(record: R): E;
+    toRedis(entity: E): R;
+}
+declare abstract class RedisRepository<E extends {
+    id: string;
+} = any, R extends object = object> {
+    protected abstract entityName: string;
+    protected converter: Converter<E, R>;
+    protected config: RedisConfig;
+    protected client: RedisClientType;
+    constructor();
+    init(): Promise<void>;
+    list(): Promise<Awaited<E>[]>;
+    get(id: string): Promise<E>;
+    create(entity: E): Promise<E>;
+    update(entity: any): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteAll(): Promise<void>;
+    getKey(id: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedisRepository<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RedisRepository<any, any>>;
+}
+
+export { Converter, REDIS_CONFIG, RedisRepository, provideRedisConfig };
+export type { RedisConfig };

package/auth/index.d.ts

@@ -1 +1,16 @@
-export * from './auth.service';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare abstract class AuthService {
+    abstract readonly auth$: Observable<any>;
+    abstract readonly auth: Signal<any>;
+    abstract readonly accessToken$: Observable<string>;
+    abstract readonly accessToken: Signal<string>;
+    abstract signIn(): Promise<any>;
+    abstract signOut(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+export { AuthService };

package/azure-auth/index.d.ts

@@ -1,2 +1,41 @@
-export * from './auth.di';
-export * from './auth.service';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { MsalService } from '@azure/msal-angular';
+import { Configuration, AccountInfo } from '@azure/msal-browser';
+import { HttpClient } from '@angular/common/http';
+
+declare abstract class AuthService {
+    abstract readonly auth$: Observable<any>;
+    abstract readonly accessToken$: Observable<string>;
+    abstract signIn(): Promise<any>;
+    abstract signOut(): Promise<void>;
+}
+interface AzureAuthConfig {
+    configuration: Configuration;
+    scopes: string[];
+}
+declare const AZURE_AUTH_CONFIG: InjectionToken<AzureAuthConfig>;
+declare class AzureAuthService extends AuthService {
+    msal: MsalService;
+    protected readonly config: AzureAuthConfig;
+    readonly auth$: ReplaySubject<AccountInfo>;
+    readonly auth: _angular_core.Signal<AccountInfo>;
+    readonly accessToken: _angular_core.WritableSignal<any>;
+    readonly accessToken$: Observable<any>;
+    readonly http: HttpClient;
+    constructor(msal: MsalService);
+    initialize(): Promise<void>;
+    signIn(): Promise<any>;
+    signOut(): Promise<void>;
+    protected updateAccessToken(scopes?: string[]): Promise<void>;
+    acquireAccessToken(scopes?: string[]): Promise<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AzureAuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AzureAuthService>;
+}
+
+declare function provideAppInitializer(useValue: () => void): EnvironmentProviders;
+declare function provideAzureAuth(config: AzureAuthConfig): EnvironmentProviders;
+
+export { AZURE_AUTH_CONFIG, AzureAuthService, provideAppInitializer, provideAzureAuth };
+export type { AzureAuthConfig };

package/domain/builder/index.d.ts

@@ -0,0 +1,81 @@
+import { OpenApi, Command, Query, Database, ScreenItem } from '@xxmachina/common/domain/models';
+import { CreateActionsOptions, Action } from '@ng-atomic/core';
+import { NavigationExtras } from '@angular/router';
+
+declare class CommandBuilder {
+    buildFromOpenApi(openApi: OpenApi): Command[];
+}
+
+declare enum ActionId {
+    NAVIGATE_TO_COMMAND_PAGE = "[@xxmachina/common] Navigate To Command Page",
+    EXECUTE_COMMAND = "[@xxmachina/common] Execute Command"
+}
+interface CommandActionFactoryOptions extends CreateActionsOptions {
+    queryId?: string;
+    confirm?: () => Promise<boolean> | boolean;
+}
+interface CommandActionPayload<P> {
+    command: any;
+    body: P;
+    options?: {
+        confirm?: () => Promise<boolean> | boolean;
+        queryId?: string;
+    };
+}
+declare class CommandActionsBuilder {
+    private commands;
+    private options;
+    private item;
+    private filterIds;
+    private autoIds;
+    setCommands(commands: Command[]): CommandActionsBuilder;
+    setOptions(options: Partial<CommandActionFactoryOptions>): CommandActionsBuilder;
+    setItem(item: any): CommandActionsBuilder;
+    setFilterIds(filterIds?: (string | {
+        id: string;
+        auto: boolean;
+    })[]): CommandActionsBuilder;
+    setAutoIds(autoIds: string[]): CommandActionsBuilder;
+    private applyFilter;
+    buildAction(id: string): Action;
+    buildActions(item?: any, navigationExtras?: NavigationExtras, overwrite?: Partial<Action>): Action[];
+    buildItemActions<T>(): (item: T) => Action[];
+}
+declare function createCommandNavigateAction(command: Command, navigationExtras?: NavigationExtras, item?: any, options?: CommandActionFactoryOptions, overwrite?: Partial<Action>): Action | null;
+declare function createCommandExecutionAction(command: Command, item?: any, options?: CommandActionFactoryOptions, overwrite?: Partial<Action>): Action | null;
+
+interface Schema {
+    name: string;
+    fields: string[];
+    relations: Relation[];
+}
+interface Relation {
+    source: string;
+    target: string;
+    label?: string;
+    type?: string;
+}
+declare class ErBuilder {
+    build(databases: any): string;
+    parseDatabaseSchema(database: any, name?: string, map?: {
+        [key: string]: string;
+    }): Schema;
+    buildMermaidER(schemas: Schema[]): string;
+}
+
+declare class QueryBuilder {
+    static buildByGraphql(graphql: {
+        endpoint: string;
+        query: string;
+        headers: Record<string, string>;
+        variables: Record<string, any>;
+        transformerTs?: string;
+    }, meta?: Partial<Omit<Query, 'graphql'>>): Query;
+}
+
+declare class ScreenItemBuilder {
+    build(database: Database): ScreenItem[];
+}
+
+export { ActionId, CommandActionsBuilder, CommandBuilder, ErBuilder, QueryBuilder, ScreenItemBuilder, createCommandExecutionAction, createCommandNavigateAction };
+export type { CommandActionFactoryOptions, CommandActionPayload };

package/domain/builder/screen-item/index.d.ts

@@ -1 +1,7 @@
-export * from './screen-item.builder';
+import { Database, ScreenItem } from '@xxmachina/common/domain/models';
+
+declare class ScreenItemBuilder {
+    build(database: Database): ScreenItem[];
+}
+
+export { ScreenItemBuilder };

package/domain/index.d.ts

@@ -1 +1,2 @@
-export * from './models';
+export * from '@xxmachina/common/domain/builder';
+export * from '@xxmachina/common/domain/models';