9427918077

Committed 08 Jun 2024 10:00AM UTC coverage: 70.028% (+0.07%) from 69.954%

Build # 9427918077

Build Type

push

github

Committed by

vanthome

Commit Message

chore: upgrade deps

Run Details

120 of 219 branches covered (54.79%)

Branch coverage included in aggregate %.

1394 of 1943 relevant lines covered (71.74%)

3.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.12

/src/utils.ts

import {
  AuthZAction, PolicySetRQResponse, accessRequest,
  DecisionResponse, Operation, ACSClientContext, Resource
} from '@restorecommerce/acs-client';
import * as _ from 'lodash-es';
import { createServiceConfig } from '@restorecommerce/service-config';
import { createLogger } from '@restorecommerce/logger';
import { Logger } from 'winston';
import { createChannel, createClient } from '@restorecommerce/grpc-client';
import { UserServiceDefinition, UserServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/user.js';
import { HeadObjectParams } from './interfaces.js';
import { S3 } from 'aws-sdk';
import { Response_Decision } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control.js';

export interface HierarchicalScope {
  id: string;
  role?: string;
  children?: HierarchicalScope[];
}

export interface Response {
  payload: any;
  count: number;
  status?: {
    code: number;
    message: string;
  };
}

export interface FilterType {
  field?: string;
  operation?: 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'in' | 'isEmpty' | 'iLike';
  value?: string;
  type?: 'string' | 'boolean' | 'number' | 'date' | 'array';
}

// Create a ids client instance
let idsClientInstance: UserServiceClient;
const cfg = createServiceConfig(process.cwd());
const getUserServiceClient = async () => {
  if (!idsClientInstance) {
    // identity-srv client to resolve subject ID by token
    const grpcIDSConfig = cfg.get('client:user');
    const loggerCfg = cfg.get('logger');
    const logger = createLogger(loggerCfg);
    if (grpcIDSConfig) {
      idsClientInstance = createClient({
        ...grpcIDSConfig,
        logger
      }, UserServiceDefinition, createChannel(grpcIDSConfig.address));
    }
  }
  return idsClientInstance;
};

export async function checkAccessRequest(ctx: ACSClientContext, resource: Resource[], action: AuthZAction, operation: Operation.isAllowed, useCache?: boolean): Promise<DecisionResponse>;
export async function checkAccessRequest(ctx: ACSClientContext, resource: Resource[], action: AuthZAction, operation: Operation.whatIsAllowed, useCache?: boolean): Promise<PolicySetRQResponse>;

/**
 * Perform an access request using inputs from a GQL request
 *
 * @param subject Subject information
 * @param resources resources
 * @param action The action to perform
 * @param operation The operation to invoke either isAllowed or whatIsAllowed
 */
/* eslint-disable prefer-arrow-functions/prefer-arrow-functions */
export async function checkAccessRequest(ctx: ACSClientContext, resource: Resource[], action: AuthZAction,
  operation: Operation): Promise<DecisionResponse | PolicySetRQResponse> {
  let subject = ctx.subject;
  // resolve subject id using findByToken api and update subject with id
  let dbSubject;
  if (subject?.token) {
    const idsClient = await getUserServiceClient();
    if (idsClient) {
      dbSubject = await idsClient.findByToken({ token: subject.token });
      if (dbSubject?.payload?.id) {
        subject.id = dbSubject.payload.id;
      }
    }
  }

  let result: DecisionResponse | PolicySetRQResponse;
  try {
    result = await accessRequest(subject, resource, action, ctx, { operation, roleScopingEntityURN: cfg?.get('authorization:urns:roleScopingEntityURN') });
  } catch (err) {
    return {
      decision: Response_Decision.DENY,
      obligations: [],
      operation_status: {
        code: err.code || 500,
        message: err.details || err.message,
      }
    };
  }
  return result;
}

export const marshallProtobufAny = (msg: any): any => {
  return {
    type_url: '',
    value: Buffer.from(JSON.stringify(msg))
  };
};

export const unmarshallProtobufAny = (msg: any, logger: Logger): any => {
  try {
    return JSON.parse(msg.value.toString());
  } catch (error) {
    logger.error('Error unmarshalling data', { code: error.code, message: error.message, stack: error.stack });
  }
};

export const getHeadObject = async (headObjectParams: HeadObjectParams,
  ossClient: S3, logger: Logger): Promise<any> => {
  try {
    return new Promise((resolve, reject) => {
      ossClient.headObject(headObjectParams, (err: any, data) => {
        if (err) {
          // map the s3 error codes to standard chassis-srv errors
          if (err.code === 'NotFound') {
            logger.info(`Object metadata for Key ${headObjectParams.Key} not found`);
            resolve({
              status: {
                id: headObjectParams.Key,
                code: 404,
                message: err.message ? err.message : `Object metadata for Key ${headObjectParams.Key} not found`
              }
            });
          }
          logger.error('Error occurred while retrieving metadata for object',
            {
              Bucket: headObjectParams.Bucket, Key: headObjectParams.Key, error: err, errorStack: err.stack
            });
          if (!err.message) {
            err.message = err.name;
          }
          reject(err);
        } else {
          logger.debug(`Object metadata for Key ${headObjectParams.Key}`, data);
          resolve(data);
        }
      });
    });
  } catch (error) {
    logger.error('Error occurred while retrieving metadata for object', { code: error.code, message: error.message, stack: error.stack });
    const code = Number.isNaN(error.code) ? 500 : error.code;
    return {
      status: {
        id: headObjectParams.Key,
        code,
        message: error.message
      }
    };
  }
};

1	import {	1✔
2	AuthZAction, PolicySetRQResponse, accessRequest,	1✔
3	DecisionResponse, Operation, ACSClientContext, Resource	1✔
4	} from '@restorecommerce/acs-client';	1✔
5	import * as _ from 'lodash-es';	1✔
6	import { createServiceConfig } from '@restorecommerce/service-config';	1✔
7	import { createLogger } from '@restorecommerce/logger';	1✔
8	import { Logger } from 'winston';	1✔
9	import { createChannel, createClient } from '@restorecommerce/grpc-client';	1✔
10	import { UserServiceDefinition, UserServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/user.js';	1✔
11	import { HeadObjectParams } from './interfaces.js';	1✔
12	import { S3 } from 'aws-sdk';	1✔
13	import { Response_Decision } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control.js';	1✔
14		1✔
15	export interface HierarchicalScope {	1✔
16	id: string;	1✔
17	role?: string;	1✔
18	children?: HierarchicalScope[];	1✔
19	}	1✔
20		1✔
21	export interface Response {	1✔
22	payload: any;	1✔
23	count: number;	1✔
24	status?: {	1✔
25	code: number;	1✔
26	message: string;	1✔
27	};	1✔
28	}	1✔
29		1✔
30	export interface FilterType {	1✔
31	field?: string;	1✔
32	operation?: 'lt' \| 'lte' \| 'gt' \| 'gte' \| 'eq' \| 'in' \| 'isEmpty' \| 'iLike';	1✔
33	value?: string;	1✔
34	type?: 'string' \| 'boolean' \| 'number' \| 'date' \| 'array';	1✔
35	}	1✔
36		1✔
37	// Create a ids client instance	1✔
38	let idsClientInstance: UserServiceClient;	1✔
39	const cfg = createServiceConfig(process.cwd());	1✔
40	const getUserServiceClient = async () => {	1✔
41	if (!idsClientInstance) {	11✔
42	// identity-srv client to resolve subject ID by token	1✔
43	const grpcIDSConfig = cfg.get('client:user');	1✔
44	const loggerCfg = cfg.get('logger');	1✔
45	const logger = createLogger(loggerCfg);	1✔
46	if (grpcIDSConfig) {	1✔
47	idsClientInstance = createClient({	1✔
48	...grpcIDSConfig,	1✔
49	logger	1✔
50	}, UserServiceDefinition, createChannel(grpcIDSConfig.address));	1✔
51	}	1✔
52	}	1✔
53	return idsClientInstance;	11✔
54	};	11✔
55		1✔
56	export async function checkAccessRequest(ctx: ACSClientContext, resource: Resource[], action: AuthZAction, operation: Operation.isAllowed, useCache?: boolean): Promise<DecisionResponse>;	1✔
57	export async function checkAccessRequest(ctx: ACSClientContext, resource: Resource[], action: AuthZAction, operation: Operation.whatIsAllowed, useCache?: boolean): Promise<PolicySetRQResponse>;	1✔
58		1✔
59	/**	1✔
60	* Perform an access request using inputs from a GQL request	1✔
61	*	1✔
62	* @param subject Subject information	1✔
63	* @param resources resources	1✔
64	* @param action The action to perform	1✔
65	* @param operation The operation to invoke either isAllowed or whatIsAllowed	1✔
66	*/	1✔
67	/* eslint-disable prefer-arrow-functions/prefer-arrow-functions */	1✔
68	export async function checkAccessRequest(ctx: ACSClientContext, resource: Resource[], action: AuthZAction,	1✔
69	operation: Operation): Promise<DecisionResponse \| PolicySetRQResponse> {	42✔
70	let subject = ctx.subject;	42✔
71	// resolve subject id using findByToken api and update subject with id	42✔
72	let dbSubject;	42✔
73	if (subject?.token) {	42✔
74	const idsClient = await getUserServiceClient();	11✔
75	if (idsClient) {	11✔
76	dbSubject = await idsClient.findByToken({ token: subject.token });	11✔
77	if (dbSubject?.payload?.id) {	11✔
78	subject.id = dbSubject.payload.id;	11✔
79	}	11✔
80	}	11✔
81	}	11✔
82		42✔
83	let result: DecisionResponse \| PolicySetRQResponse;	42✔
84	try {	42✔
85	result = await accessRequest(subject, resource, action, ctx, { operation, roleScopingEntityURN: cfg?.get('authorization:urns:roleScopingEntityURN') });	42✔
86	} catch (err) {	42!
87	return {	×
88	decision: Response_Decision.DENY,	×
89	obligations: [],	×
90	operation_status: {	×
91	code: err.code \|\| 500,	×
92	message: err.details \|\| err.message,	×
93	}	×
94	};	×
95	}	×
96	return result;	42✔
97	}	42✔
98		1✔
99	export const marshallProtobufAny = (msg: any): any => {	1✔
100	return {	8✔
101	type_url: '',	8✔
102	value: Buffer.from(JSON.stringify(msg))	8✔
103	};	8✔
104	};	8✔
105		1✔
106	export const unmarshallProtobufAny = (msg: any, logger: Logger): any => {	1✔
107	try {	1✔
108	return JSON.parse(msg.value.toString());	1✔
109	} catch (error) {	1!
110	logger.error('Error unmarshalling data', { code: error.code, message: error.message, stack: error.stack });	×
111	}	×
112	};	1✔
113		1✔
114	export const getHeadObject = async (headObjectParams: HeadObjectParams,	1✔
115	ossClient: S3, logger: Logger): Promise<any> => {	29✔
116	try {	29✔
117	return new Promise((resolve, reject) => {	29✔
118	ossClient.headObject(headObjectParams, (err: any, data) => {	29✔
119	if (err) {	29!
120	// map the s3 error codes to standard chassis-srv errors	×
121	if (err.code === 'NotFound') {	×
122	logger.info(`Object metadata for Key ${headObjectParams.Key} not found`);	×
123	resolve({	×
124	status: {	×
125	id: headObjectParams.Key,	×
126	code: 404,	×
127	message: err.message ? err.message : `Object metadata for Key ${headObjectParams.Key} not found`	×
128	}	×
129	});	×
130	}	×
131	logger.error('Error occurred while retrieving metadata for object',	×
132	{	×
133	Bucket: headObjectParams.Bucket, Key: headObjectParams.Key, error: err, errorStack: err.stack	×
134	});	×
135	if (!err.message) {	×
136	err.message = err.name;	×
137	}	×
138	reject(err);	×
139	} else {	29✔
140	logger.debug(`Object metadata for Key ${headObjectParams.Key}`, data);	29✔
141	resolve(data);	29✔
142	}	29✔
143	});	29✔
144	});	29✔
145	} catch (error) {	29!
146	logger.error('Error occurred while retrieving metadata for object', { code: error.code, message: error.message, stack: error.stack });	×
147	const code = Number.isNaN(error.code) ? 500 : error.code;	×
148	return {	×
149	status: {	×
150	id: headObjectParams.Key,	×
151	code,	×
152	message: error.message	×
153	}	×
154	};	×
155	}	×
156	};	29✔

restorecommerce / ostorage-srv / 9427918077

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous