@laiye_packages/uci 1.0.0

package/dist/app/base/index.d.ts

@@ -0,0 +1,80 @@
+import { LYObject } from '../../object';
+import { LYAppHttpClient, LYTenantHttpClient, type IHeaderProvider } from '../../http';
+import type { LYAppPermission } from '../../permission';
+import { LYi18n, ILYi18n, LYKeyofLang } from '../../i18n';
+import { ILYStorageSync, ILYStorage } from '../../storage';
+import { LYEnv } from '../../env';
+export declare const TENANT_APP_NAME = "tenant";
+export declare const ORGANIZATION_APP_NAME = "organization";
+export interface LYAppRemoteModule<Host, LYComponents> {
+    default(host: Host): LYComponents | Promise<LYComponents>;
+}
+export type ILanguageResources = {
+    [key in LYKeyofLang]: Object;
+};
+export interface ILYAppProvider {
+    provideI18nResource: (app: LYBaseApp) => Promise<ILanguageResources>;
+    provideI18nResourcePath: (app: LYBaseApp, lang?: string) => string;
+}
+export declare class LYDefaultAppProvider extends LYObject implements ILYAppProvider {
+    provideI18nResourcePath(app: LYBaseApp, lang?: string): string;
+    provideI18nResource(app: LYBaseApp): Promise<ILanguageResources>;
+}
+export declare class LYBaseApp extends LYObject {
+    private static _apps;
+    private static _headerProvider;
+    private static _initLock;
+    static get apps(): Record<string, LYBaseApp>;
+    /**
+     * 根据应用名称动态生成对应的类名
+     * 例如: agent_system -> LYAgentSystemApp
+     */
+    private static getAppClassName;
+    static init(config_url?: string): Promise<void>;
+    protected _name: string;
+    protected _version: string;
+    protected _description: string;
+    protected _httpClient: LYAppHttpClient;
+    protected _isLoaded: boolean;
+    protected _i18n: LYi18n;
+    protected _localStore: ILYStorageSync;
+    protected _sessionStore: ILYStorageSync;
+    protected _cloudStore: ILYStorage;
+    protected _provider: ILYAppProvider;
+    protected _env: LYEnv;
+    protected _tenantName: string;
+    protected _isLoadingComponent: boolean;
+    protected _remoteComponents: {
+        [name: string]: any;
+    };
+    static getAll(): Record<string, LYBaseApp>;
+    static get<T extends LYBaseApp = LYBaseApp>(name: string): T;
+    static setHeaderProvider(headerProvider: IHeaderProvider): void;
+    static getHeaderProvider(): IHeaderProvider;
+    constructor(name: string, version: string, description: string);
+    get location(): string;
+    get name(): string;
+    get tenantName(): string;
+    get version(): string;
+    get description(): string;
+    get httpClient(): LYAppHttpClient;
+    get permission(): LYAppPermission;
+    get provider(): ILYAppProvider;
+    get i18n(): ILYi18n;
+    get localStore(): ILYStorageSync;
+    get sessionStore(): ILYStorageSync;
+    get cloudStore(): ILYStorage;
+    get isLoaded(): boolean;
+    get env(): LYEnv;
+    protected _createHttpClient(): LYAppHttpClient;
+    load(): Promise<void>;
+    private getBaseUrl;
+    protected doLoad(): Promise<void>;
+    private initI18n;
+    getI18nResourceUrl(relativeUrl: string, lang?: LYKeyofLang): string;
+    getComponent<T>(componentName: string): Promise<T>;
+    private loadRemoteComponents;
+}
+export declare class LYBaseTenantApp extends LYBaseApp {
+    protected _createHttpClient(): LYTenantHttpClient;
+}

package/dist/app/index.d.ts

@@ -0,0 +1,14 @@
+import { LYEnv } from '../env';
+import { LYBaseApp, LYBaseTenantApp, ORGANIZATION_APP_NAME, TENANT_APP_NAME } from './base';
+import { LYOrganizationApp, SSOConfig } from './organization';
+import { LYTenantApp } from './tenant';
+import { LYTenantSession } from './tenant/session';
+import { LYWebAuthorizer } from './organization/authorizer/web';
+import { LYGatewayAuthorizer } from './organization/authorizer/gateway';
+import { LYDirectAuthorizer } from './organization/authorizer/direct';
+import { LYRedirectAuthorizer } from './organization/authorizer/redirect';
+import { LYTenantAuthorizer } from './tenant/authorizer';
+declare class LYApp extends LYBaseTenantApp {
+}
+export type { SSOConfig };
+export { LYApp, LYBaseApp, LYTenantApp, LYOrganizationApp, LYTenantSession, TENANT_APP_NAME, ORGANIZATION_APP_NAME, LYEnv, LYWebAuthorizer, LYGatewayAuthorizer, LYDirectAuthorizer, LYRedirectAuthorizer, LYTenantAuthorizer };

package/dist/app/organization/api/department.d.ts

@@ -0,0 +1,44 @@
+import type { LYRangeQueryParams, LYAppHttpClient, LYBaseResponse, LYListResponse } from '../../../http';
+interface LYDepartmentQueryParams extends LYRangeQueryParams {
+    name_or_code?: string;
+    parent_id?: string;
+    user_id?: string;
+    manager_only?: boolean;
+}
+interface LYDepartmentResponse extends LYBaseResponse {
+    id: string;
+    name: string;
+    description: string;
+    parent_id: string;
+    path: string;
+    code: string;
+    sort: number;
+}
+interface LYDepartmentParentRequest {
+    id: string;
+    path: string;
+}
+interface LYDepartmentPostRequest {
+    name: string;
+    description?: string;
+    code?: string;
+    sort?: number;
+    parent?: LYDepartmentParentRequest;
+}
+interface LYDepartmentPatchRequest {
+    name?: string;
+    description?: string;
+    code?: string;
+    sort?: number;
+    parent?: LYDepartmentParentRequest;
+}
+export declare class LYDepartmentApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    query(params: LYDepartmentQueryParams): Promise<LYListResponse<LYDepartmentResponse>>;
+    get(id: string): Promise<LYDepartmentResponse | undefined>;
+    add(department: LYDepartmentPostRequest): Promise<string>;
+    update(id: string, department: LYDepartmentPatchRequest): Promise<number>;
+    remove(id: string): Promise<number>;
+}
+export {};

package/dist/app/organization/api/license.d.ts

@@ -0,0 +1,60 @@
+import type { LYBasicResultCode } from '../../../http/error';
+import type { LYAppHttpClient, LYBaseResponse, LYListResponse } from '../../../http';
+export type LYLicenseResultCode = LYBasicResultCode | 'not_match';
+interface LYLicenseFileResponse extends LYBaseResponse {
+    id: string;
+    file_name: string;
+}
+interface LYLicenseContentResponse extends LYBaseResponse {
+    signature: string;
+    id: string;
+    app_name: string;
+    app_version: string;
+    name: string;
+    activation_at: string;
+    expiration_at: string;
+    usage_period: number;
+    quantity: number;
+    counter: number;
+}
+interface LYLicenseFileContentResponse extends LYBaseResponse {
+    id: string;
+    file_name: string;
+    customer: string;
+    env_code: string;
+    items: LYLicenseContentResponse[];
+}
+interface LYLicensePostRequest {
+    content: string;
+}
+interface LYLicenseTokenResponse extends LYBaseResponse {
+    id: string;
+    license_id: string;
+    ordinal: number;
+    acquire_id: string;
+    expire_at: string;
+    message: string;
+}
+interface LYLicenseLogResponse extends LYBaseResponse {
+    id: string;
+    action: string;
+    failed: boolean;
+    message: string;
+    inner_message: string;
+    license_id: string;
+    license_token_id: string;
+}
+export declare class LYLicenseApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    queryFiles(): Promise<LYListResponse<LYLicenseFileResponse>>;
+    getFileContent(id: string): Promise<LYLicenseFileContentResponse | undefined>;
+    add(license: LYLicensePostRequest): Promise<string>;
+    getAll(): Promise<LYListResponse<LYLicenseContentResponse>>;
+    get(id: string): Promise<LYLicenseContentResponse | undefined>;
+    remove(id: string): Promise<number>;
+    getTokens(): Promise<LYListResponse<LYLicenseTokenResponse>>;
+    getToken(id: string): Promise<LYLicenseTokenResponse | undefined>;
+    getLogs(licenseId: string, tokenId?: string): Promise<LYListResponse<LYLicenseLogResponse>>;
+}
+export {};

package/dist/app/organization/api/notification.d.ts

@@ -0,0 +1,98 @@
+import type { LYRangeQueryParams, LYAppHttpClient, LYBaseResponse, LYListResponse } from '../../../http';
+export type LYChannelType = 'email' | 'inbox' | 'external';
+interface LYChannelQueryParams extends LYRangeQueryParams {
+    name?: string;
+    type?: LYChannelType;
+    enabled?: boolean;
+}
+interface LYChannelResponse extends LYBaseResponse {
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+    updated_by: string;
+    name: string;
+    description: string;
+    type: LYChannelType;
+    config: Record<string, any>;
+    enabled: boolean;
+}
+interface LYChannelPostRequest {
+    name: string;
+    description: string;
+    type: string;
+    config: Record<string, any>;
+    enabled: boolean;
+}
+interface LYChannelPatchRequest {
+    name: string;
+    description: string;
+    type: string;
+    config: Record<string, any>;
+    enabled: boolean;
+}
+export declare class LYChannelApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    query(params: LYChannelQueryParams): Promise<LYListResponse<LYChannelResponse>>;
+    get(id: string): Promise<LYChannelResponse | undefined>;
+    add(channel: LYChannelPostRequest): Promise<string>;
+    update(id: string, channel: LYChannelPatchRequest): Promise<number>;
+    remove(id: string): Promise<number>;
+}
+interface LYNotificationVariableResponse extends LYBaseResponse {
+    name: string;
+    caption: string;
+    description: string;
+}
+interface LYNotificationMetaInfoResponse extends LYBaseResponse {
+    type_caption: string;
+    variables: LYNotificationVariableResponse[];
+}
+interface LYNotificationMetaResponse extends LYBaseResponse {
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+    updated_by: string;
+    type: string;
+    meta: LYNotificationMetaInfoResponse;
+}
+interface LYNotificationTemplateQueryParams extends LYRangeQueryParams {
+    user_id: string;
+    name?: string;
+    type?: string;
+    language?: string;
+}
+interface LYNotificationTemplateResponse extends LYBaseResponse {
+    user_id: string;
+    name: string;
+    description: string;
+    type: string;
+    language: string;
+    content: string;
+}
+interface LYNotificationTemplatePostRequest {
+    user_id: string;
+    name: string;
+    description: string;
+    type: string;
+    language: string;
+    content: string;
+}
+interface LYNotificationTemplatePatchRequest {
+    name: string;
+    description: string;
+    type: string;
+    language: string;
+    content: string;
+}
+export declare class LYNotificationApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    getMeta(): Promise<LYNotificationMetaResponse | undefined>;
+    queryTemplates(params: LYNotificationTemplateQueryParams): Promise<LYListResponse<LYNotificationTemplateResponse>>;
+    getTemplate(id: string): Promise<LYNotificationTemplateResponse | undefined>;
+    addTemplate(template: LYNotificationTemplatePostRequest): Promise<string>;
+    updateTemplate(id: string, template: LYNotificationTemplatePatchRequest): Promise<number>;
+    removeTemplate(id: string): Promise<number>;
+}
+export {};

package/dist/app/organization/api/oem.d.ts

@@ -0,0 +1,39 @@
+import { LYAppHttpClient, LYBaseResponse } from "../../../http";
+interface LYTerm {
+    language: string;
+    name: string;
+}
+interface LYGetTermRequest {
+    name?: string;
+}
+interface LYGetTermResponse extends LYTerm, LYBaseResponse {
+    content: string;
+}
+interface LYCreateTermRequest extends LYTerm {
+    content: string;
+}
+interface LYCreateTermResponse extends LYTerm, LYBaseResponse {
+    content: string;
+}
+interface LYBaseResource extends LYTerm {
+    content_type: string;
+    url: string;
+}
+export declare class LYOEMApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    getTerm(request?: LYGetTermRequest): Promise<LYGetTermResponse>;
+    createTerm(request: LYCreateTermRequest): Promise<LYCreateTermResponse>;
+    batchUpdate(request: Record<string, string>): Promise<LYCreateTermResponse>;
+    update(request: LYCreateTermRequest): Promise<LYCreateTermResponse>;
+    delete(request: LYTerm): Promise<{
+        count: number;
+    }>;
+    getResource(request?: LYGetTermRequest): Promise<LYBaseResource>;
+    createResource(request: LYBaseResource): Promise<LYBaseResource>;
+    updateResource(request: LYBaseResource): Promise<LYBaseResource>;
+    deleteResource(request: LYTerm): Promise<{
+        count: number;
+    }>;
+}
+export {};

package/dist/app/organization/api/open_api.d.ts

@@ -0,0 +1,78 @@
+import type { LYAppHttpClient } from '../../../http';
+import { SortType } from './permission';
+type LYGetAccessorsRequset = {
+    name: string;
+    enabled: boolean | null;
+    offset: number;
+    size: number;
+    sort: SortType[];
+};
+type AccessorItem = {
+    id?: string;
+    name: string;
+    description: string;
+    create_at?: string;
+    updated_at?: string;
+    enabled: boolean;
+    expires_at: string;
+    ref_id: string;
+    ref_type: string;
+    permissions: Record<string, any>;
+    rate_limit: number;
+    rate_limit_period: number;
+    secret_key: string;
+    access_key: string;
+    ip_whitelist: string[];
+    debug: boolean;
+};
+type LYGetAccessorsResponse = {
+    range: {
+        offset: number;
+        size: number;
+        total: number;
+    };
+    list: AccessorItem[];
+};
+type LYAccessorWebhook = {
+    id?: string;
+    created_at?: string;
+    updated_at?: string;
+    accessor_id: string;
+    enabled: boolean;
+    url: string;
+    secret: string;
+    events: string[];
+    headers: Record<string, any>;
+    timeout_per_retry: number;
+    stop_after_delay: number;
+    retry_delay_min: number;
+    retry_delay_max: number;
+    retry_delay_multiplier: number;
+    failures_threshold: number;
+};
+export declare class LYOpenApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    getAccessors(request: LYGetAccessorsRequset): Promise<LYGetAccessorsResponse>;
+    create(request: AccessorItem): Promise<{
+        id: string;
+    }>;
+    getAccessor(id: string): Promise<AccessorItem>;
+    del(id: string): Promise<{
+        count: number;
+    }>;
+    update(id: string, request: AccessorItem): Promise<{
+        count: number;
+    }>;
+    getAccessorWebHook(id: string): Promise<LYAccessorWebhook>;
+    createWebhook(request: LYAccessorWebhook): Promise<{
+        id: string;
+    }>;
+    delWebhook(id: string): Promise<{
+        count: number;
+    }>;
+    updateWebhook(id: string, request: LYAccessorWebhook): Promise<{
+        count: number;
+    }>;
+}
+export {};

package/dist/app/organization/api/permission.d.ts

@@ -0,0 +1,71 @@
+import type { LYAppHttpClient } from '../../../http';
+export type SortType = 'created_at' | 'tenant_id' | 'updated_by' | 'acquire_id' | 'source' | 'reserved_2' | 'description' | 'name' | 'updated_at' | 'deleted' | 'reserved_1' | 'id' | 'acquire_expire';
+type LYGetRolsRequest = {
+    name: string;
+    offset: number;
+    size: number;
+    sort: SortType[];
+};
+type RoleItem = {
+    id?: string;
+    name: string;
+    description: string;
+    source?: "builtin";
+    permission_codes: Record<string, any>;
+};
+type LYGetRolsRespnose = {
+    range: {
+        offset: number;
+        size: number;
+        total: number | null;
+    };
+    list: RoleItem[];
+};
+type EntityBase = {
+    attributes: Record<string, Attribute>;
+};
+type Entity = EntityBase & {
+    type: "entity";
+    relations: Record<string, Relation>;
+};
+type UserAttribute = {
+    type: "none" | string;
+    name: string;
+    caption: string;
+};
+type Relation = EntityBase & {
+    type: "relation";
+};
+type Attribute = {
+    caption: string;
+    type: "unknown" | string;
+    options: string[];
+};
+type CodeItem = {
+    actions: string[];
+    caption: string;
+    description: string;
+};
+type Domain = {
+    codes: Record<string, CodeItem>;
+    entities: Record<string, Entity>;
+    user_attributes: Record<string, UserAttribute>;
+};
+type LYRoleMetaData = Record<string, Domain>;
+export declare class LYPermissionApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    getRoles(request: LYGetRolsRequest): Promise<LYGetRolsRespnose>;
+    addRole(request: RoleItem): Promise<{
+        id: string;
+    }>;
+    getRole(id: string): Promise<RoleItem>;
+    del(id: string): Promise<{
+        count: number;
+    }>;
+    update(id: string, role: RoleItem): Promise<{
+        count: number;
+    }>;
+    getMeta(type: "web" | "open"): Promise<LYRoleMetaData>;
+}
+export {};

package/dist/app/organization/api/session.d.ts

@@ -0,0 +1,51 @@
+import type { LYBasicResultCode } from '../../../http/error';
+import type { LYAppHttpClient, LYBaseResponse } from '../../../http';
+export type LYSessionAddResultCode = LYBasicResultCode | 'user_locked';
+export interface LYSessionResponse extends LYBaseResponse {
+    id: string;
+    access_token: string;
+    token_type: string;
+    user_id: string;
+    user_name: string;
+    expires_in: number;
+    claims: Record<string, any>;
+    permission_codes: Record<string, any>;
+    is_first_login?: boolean;
+    display_name: string;
+    email: string;
+    phone: string;
+    country_code: string;
+}
+export interface LYSessionPostRequest {
+    name?: string;
+    password?: string;
+    email?: string;
+    phone?: string;
+    country_code?: string;
+    account_type?: "email" | "phone";
+    verification_code?: string;
+    verification_code_id?: string;
+}
+export type SSOConfig = {
+    id: string;
+    name: string;
+    description: string;
+    authentication_type: string;
+    icon: string;
+    auth_url: string;
+    enabled: boolean;
+};
+export interface LYLoginWays {
+    allow_phone_login: boolean;
+    allow_email_login: boolean;
+    allow_username_login: boolean;
+    sso_list: SSOConfig[];
+}
+export declare class LYSessionApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    create(request: LYSessionPostRequest): Promise<LYSessionResponse>;
+    update(id: string): Promise<LYSessionResponse>;
+    delete(id: string): Promise<number>;
+    getLoginWays(): Promise<LYLoginWays>;
+}

package/dist/app/organization/api/user.d.ts

@@ -0,0 +1,95 @@
+import type { LYRangeQueryParams, LYAppHttpClient, LYBaseResponse, LYListResponse } from '../../../http';
+type LYSourceType = 'builtin' | 'web' | 'sso' | string;
+interface LYUserQueryParams extends LYRangeQueryParams {
+    name?: string;
+    role_id?: string;
+    email?: string;
+    phone?: string;
+    department_id?: string;
+    manager_only?: boolean;
+}
+interface LYAccountCheckRequest {
+    email?: string;
+    phone?: string;
+    account_type?: "email" | "phone";
+    country_code?: string;
+}
+interface LYUserRegisterResonse extends LYBaseResponse {
+    user_id: string;
+    message: string;
+    email_verified: boolean;
+    phone_verified: boolean;
+}
+interface LYUserResponse extends LYBaseResponse {
+    id: string;
+    name: string;
+    role_id: string;
+    source: LYSourceType;
+    email: string;
+    phone: string;
+    is_super_admin: boolean;
+    description: string;
+    is_locked: boolean;
+    locked_at: string;
+    locked_by: string;
+    login_failures: number;
+    last_login_at: string;
+    last_login_ip: string;
+    last_login_location: string;
+    last_login_device: string;
+    last_login_browser: string;
+    last_login_os: string;
+}
+interface LYUserListResponse extends LYListResponse<LYUserResponse> {
+}
+interface LYUserPostRequest {
+    name: string;
+    password: string;
+    description?: string;
+    role_id?: string;
+    email?: string;
+    phone?: string;
+}
+interface LYUserPatchRequest {
+    password?: string;
+    description?: string;
+    is_locked?: boolean;
+    role_id?: string;
+    email?: string;
+    phone?: string;
+}
+interface LYRegisterRequest {
+    email?: string;
+    phone?: string;
+    country_code?: string;
+    account_type: string;
+    password: string;
+    display_name?: string;
+}
+interface LYResetPasswordRequest {
+    account_type: "email" | "phone";
+    verification_code_id: string;
+    new_password: string;
+    email?: string;
+    country_code?: string;
+    phone?: string;
+}
+export declare class LYUserApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    query(params: LYUserQueryParams): Promise<LYUserListResponse>;
+    get(name: string): Promise<LYUserResponse | undefined>;
+    add(user: LYUserPostRequest): Promise<string>;
+    update(name: string, user: LYUserPatchRequest): Promise<number>;
+    remove(name: string): Promise<number>;
+    accountCheck(request: LYAccountCheckRequest): Promise<boolean>;
+    register(request: LYRegisterRequest): Promise<LYUserRegisterResonse>;
+    userNameCheck(name: string): Promise<boolean>;
+    changePassword(currentPassword: string, newPassword: string): Promise<{
+        message: string;
+    }>;
+    resetPassword(request: LYResetPasswordRequest): Promise<{
+        message: string;
+    }>;
+}
+export {};

package/dist/app/organization/api/verificationCodes.d.ts

@@ -0,0 +1,27 @@
+import type { LYAppHttpClient, LYBaseResponse } from '../../../http';
+interface LYVerificationCodeRequest {
+    email?: string;
+    phone?: string;
+    country_code?: string;
+    account_type: "email" | "phone";
+    purpose: 'register' | 'login' | 'reset_password';
+    verification_code_id?: string;
+    verification_code?: string;
+}
+interface LYVerificationCodesResponse extends LYBaseResponse {
+    message: string;
+    cooldown_seconds: number;
+    expires_in: number;
+    verification_code_id: string;
+}
+export declare class LYVerificationCodesApi {
+    private _httpClient;
+    constructor(httpClient: LYAppHttpClient);
+    send(request: LYVerificationCodeRequest): Promise<LYVerificationCodesResponse>;
+    check(request: LYVerificationCodeRequest): Promise<{
+        verified: boolean;
+        verification_code_id: string;
+        expires_at: string;
+    }>;
+}
+export {};