@fixefy/fixefy-ui-utils 0.0.17 → 0.0.19

package/dist/aws/aws_s3_helper.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react" // //@ts-nocheck
+ // import { ListObjectOutput } from './data_models'
+ // import { SignedUrl } from './data_models'
+ // import AWS from 'aws-sdk'
+ // import PaginationHelper from './pagination_helper'
+ // const s3Credentials: AWS.Credentials = new AWS.Credentials({
+ //     accessKeyId: process.env.AWS_S3_ACCESS_KEY || '',
+ //     secretAccessKey: process.env.AWS_S3_SECRET_KEY || '',
+ //   }),
+ //   awsS3: AWS.S3 = new AWS.S3({ credentials: s3Credentials })
+ // const AwsS3Helper = {
+ //   copyMyReport: async (args: any): Promise<any> => {
+ //     const {
+ //       data: { from, to },
+ //     }: { data: { from: string; to: string } } = args
+ //     // set the params
+ //     const prefixFrom = `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //         parent,
+ //         args,
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )}/${ctx.workspace?.readable_id}/${ctx.user?.username}/${from}`,
+ //       prefixTo = `${ctx.workspace?.readable_id}/${ctx.user?.username}/${to}`,
+ //       params: any = {
+ //         Bucket: `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //           parent,
+ //           args,
+ //           ctx,
+ //           info,
+ //           rest,
+ //         )}`,
+ //         CopySource: prefixFrom,
+ //         Key: prefixTo,
+ //       }
+ //     const rv: any = await awsS3.copyObject(params).promise()
+ //     // notify
+ //     NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     return rv
+ //   },
+ //   createBucket: async (args: any): Promise<AWS.S3.Types.CreateBucketOutput> => {
+ //     const {
+ //         data: { name },
+ //       }: { data: { name: string } } = args,
+ //       params: AWS.S3.Types.CreateBucketRequest = { Bucket: name }
+ //     // create bucket
+ //     const rv = await awsS3.createBucket(params).promise()
+ //     // notify
+ //     NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     return rv
+ //   },
+ //   deleteBucket: async (args: any): Promise<any> => {
+ //     const {
+ //         data: { name },
+ //       }: { data: { name: string } } = args,
+ //       params: AWS.S3.Types.DeleteBucketRequest = { Bucket: name }
+ //     const rv: any = await awsS3.deleteBucket(params).promise()
+ //     // notify
+ //     NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     return rv
+ //   },
+ //   deleteMyReport: async (args: any): Promise<any> => {
+ //     const {
+ //       data: { is_notify: isNotify = true, name },
+ //     }: { data: { is_notify: boolean; name: string } } = args
+ //     // set the prefix
+ //     const prefix = `${ctx.workspace?.readable_id}/${ctx.user?.username}/${name}`
+ //     // set the params
+ //     const params: AWS.S3.Types.DeleteObjectRequest = {
+ //       Bucket: `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //         parent,
+ //         args,
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )}`,
+ //       Key: prefix,
+ //     }
+ //     // delete object
+ //     const rv: any = await awsS3.deleteObject(params).promise()
+ //     // input check - if is_notify
+ //     if (isNotify) {
+ //       // notify
+ //       NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     }
+ //     return rv
+ //   },
+ //   deleteMyReports: async (args: any): Promise<any> => {
+ //     const {
+ //       data: { names },
+ //     }: { data: { names: Array<string> } } = args
+ //     // set the prefix
+ //     const prefix = `${ctx.workspace?.readable_id}/${ctx.user?.username}`
+ //     const promises: Array<Promise<any>> = []
+ //     let currentPromise: Promise<any>
+ //     for (const name of names) {
+ //       currentPromise = AwsS3Helper.deleteMyReport(
+ //         parent,
+ //         { data: { is_notify: false, name } },
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )
+ //       promises.push(currentPromise)
+ //     }
+ //     const resultArray: Array<any> = await Promise.all(promises),
+ //       rv: any = {}
+ //     // set the params
+ //     const params: AWS.S3.Types.DeleteObjectRequest = {
+ //       Bucket: `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //         parent,
+ //         args,
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )}`,
+ //       Key: prefix,
+ //     }
+ //     for (let i = 0; i < resultArray.length; ++i) {
+ //       rv[names[i]] = resultArray[i]
+ //     }
+ //     // notify
+ //     NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     return rv
+ //   },
+ //   deleteBucket: async (
+ //     parent: any,
+ //     args: any,
+ //     ctx: Context,
+ //     info: any,
+ //     rest: any,
+ //   ): Promise<DeleteBucketCommandOutput> => {
+ //     const {
+ //       data: { name },
+ //     } = args
+ //     // create the delete command
+ //     const command: DeleteBucketCommand = new DeleteBucketCommand({
+ //       Bucket: name,
+ //     })
+ //     // delete bucket
+ //     const rv: DeleteBucketCommandOutput = await s3.deleteBucket(command)
+ //     return rv
+ //   },
+ //   deleteFile: async (
+ //     parent: any,
+ //     args: any,
+ //     ctx: Context,
+ //     info: any,
+ //     rest: any,
+ //   ): Promise<DeleteObjectCommandOutput> => {
+ //     const {
+ //       data: { bucket_name, name },
+ //     } = args
+ //     // create the delete command
+ //     const command: DeleteObjectCommand = new DeleteObjectCommand({
+ //       Bucket: bucket_name,
+ //       Key: name,
+ //     })
+ //     // delete bucket
+ //     const rv: DeleteObjectCommandOutput = await s3Client.send(command)
+ //     return rv
+ //   },
+ //   downloadObject: async (args: any): Promise<AWS.S3.Types.GetObjectOutput> => {
+ //     const {
+ //         data: { bucket_name, name },
+ //       } = args,
+ //       params: AWS.S3.Types.GetObjectRequest = { Bucket: bucket_name, Key: name }
+ //     const rv: AWS.S3.Types.GetObjectOutput = await s3
+ //       .getObject(params)
+ //       .promise()
+ //     return rv
+ //   },
+ //   getBucketEnvSuffix: (args: any): string => {
+ //     const { env } = args
+ //     let rv: string
+ //     switch (env) {
+ //       case 'local':
+ //         rv = '-dev'
+ //         break
+ //       case 'prod':
+ //         rv = ''
+ //         break
+ //       default:
+ //         rv = `-${env}`
+ //         break
+ //     }
+ //     return rv
+ //   },
+ //   getFuegoUploadUrl: (args: any): SignedUrl => {
+ //     const {
+ //       username,
+ //       workspace,
+ //       where: { expires_in, name },
+ //     } = args
+ //     if (name == null || name.length == 0)
+ //       throw new Error('name is an empty string')
+ //     const currentPrefix = `${workspace}/${username}/${name}`,
+ //       currentParams: unknown = {
+ //         Bucket: `fixefy-fuegos${AwsS3Helper.getBucketEnvSuffix(args)}`,
+ //         Key: currentPrefix,
+ //         Expires: expires_in || 3600,
+ //       },
+ //       url: string = awsS3.getSignedUrl('putObject', currentParams),
+ //       rv: SignedUrl = { name, url }
+ //     return rv
+ //   },
+ //   getReportDownloadUrl: (args: any): string => {
+ //     const {
+ //         where: { expires_in, name },
+ //       }: { where: { expires_in: string; name: string } } = args,
+ //       prefix = `${ctx.workspace?.readable_id}/${ctx.user?.username}/${name}`,
+ //       params: any = {
+ //         Bucket: `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //           parent,
+ //           args,
+ //           ctx,
+ //           info,
+ //           rest,
+ //         )}`,
+ //         Key: prefix,
+ //         Expires: expires_in || 3600,
+ //       }
+ //     // get the signed url
+ //     const rv: string = awsS3.getSignedUrl('getObject', params)
+ //     return rv
+ //   },
+ //   getMyReports: async (args: any): Promise<Array<ListObjectOutput>> => {
+ //     // set limits
+ //     PaginationHelper.limitPagination(parent, args, ctx, info, rest)
+ //     const prefix = `${ctx.workspace?.readable_id}/${ctx.user?.username}/`,
+ //       params: AWS.S3.ListObjectsV2Request = {
+ //         Bucket: `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //           parent,
+ //           args,
+ //           ctx,
+ //           info,
+ //           rest,
+ //         )}`,
+ //         Prefix: prefix,
+ //       },
+ //       result: AWS.S3.ListObjectsV2Output = await awsS3
+ //         .listObjectsV2(params)
+ //         .promise(),
+ //       rv: Array<ListObjectOutput> = []
+ //     let headParams: AWS.S3.Types.HeadObjectRequest,
+ //       headResult: AWS.S3.Types.HeadObjectOutput,
+ //       currentObject: ListObjectOutput,
+ //       currentFileName: Maybe<string>,
+ //       currentUrl: Maybe<string>
+ //     for (const content of result?.Contents || []) {
+ //       // input check - if key is invalid - continue loop
+ //       if (ValidateHelper.isStringValid(content?.Key) == false) continue
+ //       currentFileName = content?.Key?.split('/').pop()
+ //       // input check - if file_name is invalid - continue loop
+ //       if (ValidateHelper.isStringValid(currentFileName) == false) continue
+ //       currentUrl = AwsS3Helper.getReportDownloadUrl(
+ //         parent,
+ //         { where: { name: currentFileName } },
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )
+ //       currentObject = {
+ //         name: currentFileName,
+ //         size: content.Size,
+ //         updated_at: content.LastModified?.getTime(),
+ //         url: currentUrl,
+ //       }
+ //       headParams = {
+ //         Bucket: `fixefy-reports${AwsS3Helper.getBucketEnvSuffix(
+ //           parent,
+ //           args,
+ //           ctx,
+ //           info,
+ //           rest,
+ //         )}`,
+ //         Key: content.Key as string,
+ //       }
+ //       headResult = await awsS3.headObject(headParams).promise()
+ //       // input check - if headResult.Metadata is valid
+ //       if (ValidateHelper.isObjectValid(headResult?.Metadata)) {
+ //         currentObject.description = headResult?.Metadata?.description
+ //         currentObject.report = headResult?.Metadata?.report
+ //         currentObject.title = headResult?.Metadata?.title
+ //         currentObject.updated_by = headResult?.Metadata?.updated_by
+ //       }
+ //       rv.push(currentObject)
+ //     }
+ //     return rv
+ //   },
+ //   listObjectsV2: async (args: any): Promise<AWS.S3.ListObjectsV2Output> => {
+ //     // set first/last limits
+ //     PaginationHelper.limitPagination(parent, args, ctx, info, rest)
+ //     const {
+ //       where: { bucket_name },
+ //       first,
+ //       skip,
+ //     } = args
+ //     const params: AWS.S3.ListObjectsV2Request = {
+ //       Bucket: `${bucket_name}${AwsS3Helper.getBucketEnvSuffix(
+ //         parent,
+ //         args,
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )}`,
+ //       MaxKeys: first,
+ //       StartAfter: `${skip}`,
+ //     }
+ //     const rv: AWS.S3.ListObjectsV2Output = await awsS3
+ //       .listObjectsV2(params)
+ //       .promise()
+ //     return rv
+ //   },
+ //   moveMyReport: async (args: any): Promise<never> => {
+ //     throw new ApolloError('not yet implemented')
+ //   },
+ //   renameMyReport: async (args: any): Promise<any> => {
+ //     const {
+ //       data: { from },
+ //     }: { data: { from: string } } = args
+ //     const copyResult: any = await AwsS3Helper.copyMyReport(
+ //         parent,
+ //         args,
+ //         ctx,
+ //         info,
+ //         rest,
+ //       ),
+ //       rv: any = await AwsS3Helper.deleteMyReport(
+ //         parent,
+ //         { data: { name: from } },
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )
+ //     // notify
+ //     NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     return rv
+ //   },
+ //   toListObject: (args: any): ListObject => {
+ //     const result: AWS.S3.ListObjectsV2Output = args.data.result,
+ //       rv: ListObject = {
+ //         common_prefixes: AwsHelper.toListObjectCommonPrefixArray(
+ //           parent,
+ //           { data: { prefixes: result.CommonPrefixes } },
+ //           ctx,
+ //           info,
+ //           rest,
+ //         ),
+ //         contents: AwsHelper.toListObjectContentArray(
+ //           parent,
+ //           { data: { contents: result.Contents } },
+ //           ctx,
+ //           info,
+ //           rest,
+ //         ),
+ //         is_truncated: result.IsTruncated,
+ //         key_count: result.KeyCount,
+ //         max_keys: result.MaxKeys,
+ //         name: result.Name,
+ //         prefix: result.Prefix,
+ //         start_after: result.StartAfter,
+ //       }
+ //     return rv
+ //   },
+ //   toListObjectCommonPrefixArray: (args: any): Array<ListObjectCommonPrefix> => {
+ //     const prefixes: Array<AWS.S3.Types.CommonPrefix> = args.data.prefixes,
+ //       rv: Array<ListObjectCommonPrefix> = prefixes.map((p) => {
+ //         return { prefix: p.Prefix }
+ //       })
+ //     return rv
+ //   },
+ //   toListObjectContentArray: (args: any): Array<ListObjectContent> => {
+ //     const contents: Array<AWS.S3.Types.Object> = args.data.contents,
+ //       rv: Array<ListObjectContent> = contents.map((c) => {
+ //         return {
+ //           e_tag: c.ETag,
+ //           name: c.Key,
+ //           last_modified:
+ //             c.LastModified != null
+ //               ? new Date(c.LastModified).getTime()
+ //               : undefined,
+ //           size: c.Size,
+ //           storage_class: c.StorageClass,
+ //         }
+ //       })
+ //     return rv
+ //   },
+ //   uploadObject: async (args: any): Promise<AWS.S3.ManagedUpload.SendData> => {
+ //     const {
+ //       data: {
+ //         bucket_name,
+ //         content,
+ //         description = '',
+ //         file_name: fileName,
+ //         name,
+ //         title = '',
+ //       },
+ //     }: {
+ //       data: {
+ //         bucket_name: string
+ //         content: string
+ //         description: string
+ //         file_name: string
+ //         name: string
+ //         title: string
+ //       }
+ //     } = args
+ //     const params: AWS.S3.Types.PutObjectRequest = {
+ //       Bucket: `${bucket_name}${AwsS3Helper.getBucketEnvSuffix(
+ //         parent,
+ //         args,
+ //         ctx,
+ //         info,
+ //         rest,
+ //       )}`,
+ //       Key: fileName,
+ //       Body: content,
+ //       Metadata: {
+ //         description,
+ //         name,
+ //         //report: report?.readable_id,
+ //         title,
+ //         updated_by: ctx.user.username,
+ //       },
+ //     }
+ //     const rv: AWS.S3.ManagedUpload.SendData = await awsS3
+ //       .upload(params)
+ //       .promise()
+ //     // notify
+ //     NotifyHelper.notify(parent, { data: { payload: rv } }, ctx, info, rest)
+ //     return rv
+ //   },
+ //   validateCreateFolder: async (
+ //     parent: any,
+ //     args: any,
+ //     ctx: Context,
+ //     info: any,
+ //     rest: any,
+ //   ): Promise<any> => {
+ //     let {
+ //       data: { bucket_name, name },
+ //     } = args
+ //     if (name == null) throw new ApolloError('name cannot be null')
+ //     name = name.trim()
+ //     if (ValidateHelper.isStringValid(name) == false)
+ //       throw new ApolloError(
+ //         'name must contain at least one non-space character',
+ //       )
+ //     if (name.includes('/')) throw new ApolloError('name cannot contain slashes')
+ //     // const headRes = await s3.headObject({ Bucket: bucket_name, Key: name }, () => { })).promise()
+ //     // if(headRes. )
+ //   },
+ // }
+ // export { AwsS3Helper }
+));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}

package/dist/aws/data_models.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/aws/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./aws_lambda_helper"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/{dist-types → dist}/commander/index.d.ts

@@ -7,7 +7,7 @@ export declare const determineIconByEvent: (event: {
 }) => string | undefined;
 export declare const formatNumberWithCommas: (number: number) => string;
 export declare const getNormalizationKeyForEntity: (entity_type: string) => string;
-export declare const getStringValueByValueType: ({ value, name }: {
+export declare const getStringValueByValueType: ({ value, name, }: {
     value: any;
     name: string;
 }) => any;
@@ -24,7 +24,9 @@ export declare const normalizeStringBodyRaw: (key: string, body: any) => any;
 export declare const titleCase: (str?: string) => string;
 export declare const toCamelCase: (inputArray: Maybe<Array<any>>) => string;
 export declare const toCamelCaseString: (input: string) => string;
-export declare const toCurrency: (input: string | number) => string | number;
+export declare const toCurrency: (input: string | number, options?: {
+    decimel: number;
+}) => string | number;
 export declare const toInitials: (str: string) => string | undefined;
 export declare const toPascalCase: (string: string, title?: boolean) => string;
 export declare const toWords: (input: Maybe<string>) => RegExpMatchArray | null | undefined;