@qrvey/assets-sharing 0.3.4-dev.2092 → 0.3.4-dev.2153

package/__test__/hasAdminRole.test.ts

@@ -1,299 +0,0 @@
-import { ORGANIZATION_QRVEY, hasAdminRole } from '../src';
-import { UserRepository } from '../src/quser/implementations/user.repository';
-
-const loginType = 'qrveyLogin';
-
-describe('Check if has admin role.', () => {
-    beforeEach(() => {
-        // User Exist
-        jest.spyOn(UserRepository.prototype, 'getOne').mockResolvedValue(
-            {} as any,
-        );
-
-        // User has no admin role
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 0,
-            items: [],
-        } as any);
-    });
-
-    test('Does not have access when: Only API Key', async () => {
-        const body = {
-            apiKey: 'api-key',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: API Key and Non existing userId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getOne').mockResolvedValue(null);
-
-        const body = {
-            apiKey: 'api-key',
-            userId: 'non-existing-user',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Has access when: API Key and Existing userId', async () => {
-        const body = {
-            apiKey: 'api-key',
-            userId: 'existing-user',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Has access when: API Key, org:0 and Existing userId', async () => {
-        const body = {
-            apiKey: 'api-key',
-            userId: 'existing-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Does not have access when: API Key, Existing userId and Non existing clientId', async () => {
-        const body = {
-            apiKey: 'api-key',
-            userId: 'existing-user',
-            clientId: 'non-existing-user',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Has access when: API Key, Existing userId and existing clientId', async () => {
-        const body = {
-            apiKey: 'api-key',
-            userId: 'existing-user',
-            clientId: 'existing-user',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Has access when: API Key, no Admin userId and admin clientId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            apiKey: 'api-key',
-            userId: 'existing-user',
-            clientId: 'admin-user',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Does not have access when: API Key, org:0 and Existing userId', async () => {
-        const body = {
-            apiKey: 'api-key',
-            userId: 'existing-user',
-            orgId: 'another-org',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: InComposer only (need userId)', async () => {
-        const body = {
-            loginType,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Has access when: InComposer, org:0 and Admin userId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            loginType,
-            userId: 'admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Does not have access when: InComposer, org:0 and non Admin userId', async () => {
-        const body = {
-            loginType,
-            userId: 'non-admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: org:0 and Admin userId only', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Has access when: org:0, Admin userId and Admin ClientId (same as userId)', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'admin-user',
-            clientId: 'admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Has access when: org:0, Admin userId and Another Admin ClientId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'admin-user',
-            clientId: 'another-admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Does not have access when: org:0, Admin userId and Non Admin ClientId', async () => {
-        const body = {
-            userId: 'admin-user',
-            clientId: 'non-admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Has access when: org:0, non Admin userId and Admin ClientId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'non-admin-user',
-            clientId: 'admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(true);
-    });
-
-    test('Does not have access when: org:0, non Admin userId and non Admin ClientId', async () => {
-        const body = {
-            userId: 'non-admin-user',
-            clientId: 'another-non-admin-user',
-            orgId: ORGANIZATION_QRVEY,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: InComposer, Another org, Admin userId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'admin-user',
-            orgId: 'another-org',
-            loginType,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: InComposer, Another org, non Admin userId', async () => {
-        const body = {
-            userId: 'non-admin-user',
-            orgId: 'another-org',
-            loginType,
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: Another org, Admin userId and Admin clientId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'admin-user',
-            clientId: 'admin-user',
-            orgId: 'another-org',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: Another org, Admin userId and another Admin clientId', async () => {
-        jest.spyOn(UserRepository.prototype, 'getList').mockResolvedValue({
-            count: 1,
-            items: [{}],
-        } as any);
-
-        const body = {
-            userId: 'admin-user',
-            clientId: 'another-admin-user',
-            orgId: 'another-org',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: Another org, Admin userId and non Admin clientId', async () => {
-        const body = {
-            userId: 'admin-user',
-            clientId: 'non-admin-user',
-            orgId: 'another-org',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: Another org, non Admin userId and Admin clientId', async () => {
-        const body = {
-            userId: 'non-admin-user',
-            clientId: 'admin-user',
-            orgId: 'another-org',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-
-    test('Does not have access when: Another org, non Admin userId and non Admin clientId', async () => {
-        const body = {
-            userId: 'non-admin-user',
-            clientId: 'another-non-admin-user',
-            orgId: 'another-org',
-        };
-        const result = await hasAdminRole(body);
-        expect(result).toBe(false);
-    });
-});

package/jest.config.ts

@@ -1,15 +0,0 @@
-export default {
-    preset: 'ts-jest',
-    testEnvironment: 'node',
-    collectCoverageFrom: [
-        'src/**/*.ts',
-        '!src/**/*.test.ts',
-        '!src/**/*.spec.ts',
-        '!src/types/**/*',
-        '!src/interfaces/**/*',
-    ],
-    testPathIgnorePatterns: [
-        '<rootDir>/node_modules/',
-        '<rootDir>/__tests__/__mocks__/',
-    ],
-};

package/src/common/common.type.ts

@@ -1,33 +0,0 @@
-export interface Pagination {
-    limit: number;
-    from?: number;
-}
-
-export interface Filter {
-    column: string;
-    value: string;
-}
-
-export interface ParamsFromTokenToUser {
-    userId: string;
-    roles: string[];
-    orgId: string;
-}
-
-export interface Sorting {
-    column: string;
-    direction: 'ASC' | 'DESC';
-}
-
-export interface ListInput<T> {
-    data: T;
-    pagination?: Pagination;
-    filters?: Array<Filter>;
-    sorting?: Array<Sorting>;
-}
-
-export interface ListOutput<T> {
-    count: number;
-    items: T[];
-    pagination: Pagination;
-}

package/src/common/constants.ts

@@ -1,64 +0,0 @@
-export const ENVIRONMENT = {
-    SERVER_PREFIX: process.env.SERVER_PREFIX,
-    TABLE_PREFIX: process.env.TABLE_PREFIX,
-    DOMAIN: process.env.DOMAIN,
-    API_KEY: process.env.API_KEY,
-};
-
-export const DATABASE_INFO = {
-    DATA_PERSISTENCE_SCHEMA: 'admin',
-    SERVER_PREFIX: ENVIRONMENT.SERVER_PREFIX,
-    TABLE_PREFIX: ENVIRONMENT.TABLE_PREFIX,
-};
-
-export const ORGANIZATION_QRVEY = 'org:0';
-
-export enum ASSET_TYPE {
-    DX = 'DX', // DASHBOARD X (Next Gen)
-    DM = 'DM', // DOWNLOAD MANAGER
-}
-
-export enum SHARED_ORIGIN {
-    INTERNAL = 'INTERNAL', // for org:0
-    EXTERNAL = 'EXTERNAL', // for orgs different that 0
-    UNKNOWN = 'UNKNOWN', // without orgId
-}
-
-export enum SHARE_TYPE {
-    USER = 'USER',
-    ROLE = 'ROLE',
-    ORGANIZATION = 'ORGANIZATION',
-}
-
-/**
- * Access levels for assets.
- * Those are calculated with Base 2, so:
- * - NONE = 0 (undefined)
- * - CAN_USE = 1 (2^0)
- * - CAN_EDIT = 2 (2^1)
- * - ADMIN = 4 (2^2)
- * - (Future) SUPER = 8 (2^3)
- */
-export enum ACCESS_LEVEL {
-    NONE = 0,
-    CAN_USE = 1,
-    CAN_EDIT = 2,
-    ADMIN = 4,
-}
-
-export enum AppSharingStatus {
-    PUBLIC = 'public',
-    PRIVATE = 'private',
-}
-
-export interface AppPermissionResponse {
-    privacy: AppSharingStatus;
-}
-
-export interface AppOwner {
-    userId: string;
-    appId: string;
-    userEmail?: string;
-}
-
-export const LIMIT_PER_PAGE = 10;

package/src/common/persistence/base.ts

@@ -1,13 +0,0 @@
-import { CrudService, buildFilter } from '@qrvey/data-persistence';
-
-import { getPoolClient } from './poolClient';
-
-export class BaseRepository extends CrudService<any> {
-    constructor(schema: any) {
-        super(schema, getPoolClient());
-    }
-
-    filter(attribute: string, value: any, operator?: string) {
-        return buildFilter(attribute, value, operator);
-    }
-}

package/src/common/persistence/poolClient.ts

@@ -1,7 +0,0 @@
-import { getDbPool } from '@qrvey/data-persistence';
-
-let poolClient: any;
-export function getPoolClient() {
-    if (!poolClient) poolClient = getDbPool();
-    return poolClient;
-}

package/src/common/util.ts

@@ -1,8 +0,0 @@
-enum LOGIN_TYPES {
-    composer = 'qrveyLogin',
-    openIdComposer = 'OPENID_CREATORS',
-}
-
-export function isComposer(type: string): boolean {
-    return type === LOGIN_TYPES.composer || type === LOGIN_TYPES.openIdComposer;
-}

package/src/context.ts

@@ -1,47 +0,0 @@
-import { container } from 'tsyringe';
-
-import { GroupRepository } from './quser/implementations/group.repository';
-import { UserRepository } from './quser/implementations/user.repository';
-import { type RoleRepositoryInterface } from './quser/interfaces/rolesRepository.interface';
-import { type UserRepositoryInterface } from './quser/interfaces/userRepository.interface';
-import { AdminRepository } from './sharing/implementations/admin.repository';
-import { SharingDetailsRepository } from './sharing/implementations/details.repository';
-import { DownloadManagerRepository } from './sharing/implementations/dm.repository';
-import { DashboardRepository } from './sharing/implementations/dx.repository';
-import { OrganizationRepository } from './sharing/implementations/organization.repository';
-import { SharingRepository } from './sharing/implementations/sharing.repository';
-import { AdminRepositoryInterface } from './sharing/interfaces/adminRepository.interface';
-import { type DashboardRepositoryInterface } from './sharing/interfaces/dashboardRepository.interface';
-import { type SharingDetailsRepositoryInterface } from './sharing/interfaces/detailsRepository.interface';
-import { type DownloadManagerRepositoryInterface } from './sharing/interfaces/downloadManagerRepository.interface';
-import { OrganizationRepositoryInterface } from './sharing/interfaces/organizationRepository.interface';
-import { type SharingRepositoryInterface } from './sharing/interfaces/sharingRepository.interface';
-
-container.register<SharingRepositoryInterface>(
-    'SharingRepository',
-    SharingRepository,
-);
-container.register<SharingDetailsRepositoryInterface>(
-    'SharingDetailsRepository',
-    SharingDetailsRepository,
-);
-container.register<UserRepositoryInterface>('UserRepository', UserRepository);
-container.register<RoleRepositoryInterface>('RoleRepository', GroupRepository);
-container.register<DashboardRepositoryInterface>(
-    'dxRepository',
-    DashboardRepository,
-);
-container.register<DownloadManagerRepositoryInterface>(
-    'dmRepository',
-    DownloadManagerRepository,
-);
-container.register<OrganizationRepositoryInterface>(
-    'OrganizationRepository',
-    OrganizationRepository,
-);
-container.register<AdminRepositoryInterface>(
-    'AdminRepository',
-    AdminRepository,
-);
-
-export const Context = container;

package/src/index.ts

@@ -1,48 +0,0 @@
-import 'reflect-metadata';
-import { Context } from './context';
-import { FromTokenToUser } from './quser/services/fromTokenToUser';
-import { HasAdminRole } from './quser/services/hasAdminRole';
-import CheckAppPermissions from './sharing/services/checkAppPermissions';
-import CheckOrgPermissions from './sharing/services/checkOrgPermissions';
-import { CheckUserAccessLevel } from './sharing/services/checkUserAccessLevel';
-import { DeleteSharing } from './sharing/services/delete';
-import { ListSharing } from './sharing/services/list';
-import { UpsertSharing } from './sharing/services/upsert';
-
-export const api = {
-    upsert: (...args: Parameters<UpsertSharing['execute']>) =>
-        Context.resolve(UpsertSharing).execute(...args),
-    list: (...args: Parameters<ListSharing['execute']>) =>
-        Context.resolve(ListSharing).execute(...args),
-    delete: (...args: Parameters<DeleteSharing['execute']>) =>
-        Context.resolve(DeleteSharing).execute(...args),
-};
-
-export const checkUserAccessLevel = (
-    ...args: Parameters<CheckUserAccessLevel['execute']>
-) => Context.resolve(CheckUserAccessLevel).execute(...args);
-
-export const checkAppPermissions = (
-    ...args: Parameters<CheckAppPermissions['execute']>
-) => Context.resolve(CheckAppPermissions).execute(...args);
-
-export const checkOrgPermissions = (
-    ...args: Parameters<CheckOrgPermissions['execute']>
-) => Context.resolve(CheckOrgPermissions).execute(...args);
-
-export const fromTokenToUser = (
-    ...args: Parameters<FromTokenToUser['execute']>
-) => Context.resolve(FromTokenToUser).execute(...args);
-
-export const hasAdminRole = (...args: Parameters<HasAdminRole['execute']>) =>
-    Context.resolve(HasAdminRole).execute(...args);
-
-export {
-    ACCESS_LEVEL,
-    ASSET_TYPE,
-    ORGANIZATION_QRVEY,
-    SHARED_ORIGIN,
-    SHARE_TYPE,
-} from './common/constants';
-
-export { GetSharingList } from './sharing/entities/types/details.type';

package/src/quser/entities/types/user.type.ts

@@ -1,14 +0,0 @@
-export interface BaseUser {
-    userid: string;
-    email: string;
-    groups: string[];
-    organization: string;
-}
-
-export interface UserToken {
-    userId: string;
-    clientId?: string;
-    roles?: string[];
-    orgId?: string;
-    loginType?: string;
-}

package/src/quser/entities/user.ts

@@ -1,31 +0,0 @@
-import { BaseUser } from './types/user.type';
-
-export class User {
-    private userId: string;
-    private email: string;
-    private groups: string[];
-    private organization: string;
-
-    constructor(params: BaseUser) {
-        this.userId = params.userid;
-        this.email = params.email;
-        this.groups = params.groups;
-        this.organization = params.organization;
-    }
-
-    public get getUserId(): string {
-        return this.userId;
-    }
-
-    public get getEmail(): string {
-        return this.email;
-    }
-
-    public get getGroups(): string[] {
-        return this.groups;
-    }
-
-    public get getOrganization(): string {
-        return this.organization;
-    }
-}

package/src/quser/implementations/group.model.ts

@@ -1,18 +0,0 @@
-import { CrudSchema } from '@qrvey/data-persistence';
-
-import { DATABASE_INFO } from '../../common/constants';
-
-export class GroupModel extends CrudSchema {
-    static table = {
-        name: `${DATABASE_INFO.SERVER_PREFIX}Groups`,
-        alias: 'qv_groups',
-    };
-
-    static columns = {
-        groupid: {
-            type: 'string',
-        },
-    };
-
-    static schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
-}

package/src/quser/implementations/group.repository.ts

@@ -1,20 +0,0 @@
-import { GroupModel } from './group.model';
-import { BaseRepository } from '../../common/persistence/base';
-import { RoleRepositoryInterface } from '../interfaces/rolesRepository.interface';
-
-export class GroupRepository
-    extends BaseRepository
-    implements RoleRepositoryInterface
-{
-    constructor() {
-        super(GroupModel);
-    }
-
-    async getOne(identifier: string): Promise<{ groupid: string } | null> {
-        const params = {
-            filters: [this.filter('groupid', identifier)],
-        };
-        const response = await super.findItem(params);
-        return response as { groupid: string };
-    }
-}

package/src/quser/implementations/user.model.ts

@@ -1,23 +0,0 @@
-import { CrudSchema } from '@qrvey/data-persistence';
-
-import { DATABASE_INFO } from '../../common/constants';
-
-export class UserModel extends CrudSchema {
-    static table = {
-        name: `${DATABASE_INFO.SERVER_PREFIX}Users`,
-        alias: 'qv_users',
-    };
-
-    static columns = {
-        userid: {
-            type: 'string',
-            primary: true,
-            columnId: true,
-        },
-        groups: {
-            type: 'array',
-        },
-    };
-
-    static schema = DATABASE_INFO.DATA_PERSISTENCE_SCHEMA;
-}

package/src/quser/implementations/user.repository.ts

@@ -1,35 +0,0 @@
-import { UserModel } from './user.model';
-import { ListInput, ListOutput } from '../../common/common.type';
-import { BaseRepository } from '../../common/persistence/base';
-import { BaseUser } from '../entities/types/user.type';
-import { UserRepositoryInterface } from '../interfaces/userRepository.interface';
-
-export class UserRepository
-    extends BaseRepository
-    implements UserRepositoryInterface
-{
-    constructor() {
-        super(UserModel);
-    }
-
-    async getOne(identifier: string): Promise<BaseUser | null> {
-        const params = {
-            filters: [this.filter('userid', identifier)],
-        };
-        const response = await super.findItem(params);
-        return response as BaseUser;
-    }
-
-    async getList(
-        options: ListInput<{ identifier: string; role?: string }>,
-    ): Promise<ListOutput<BaseUser>> {
-        const params = {
-            filters: [
-                this.filter('userid', options.data.identifier),
-                this.filter('groups', options.data.role, 'CONTAINS'),
-            ],
-        };
-        const response = await super.find(params);
-        return response as ListOutput<BaseUser>;
-    }
-}