@byaga/cdk-patterns 0.8.5 → 0.9.1

package/src/RestApi.ts

@@ -1,180 +0,0 @@
-import {
-    BasePathMapping,
-    ContentHandling,
-    DomainName,
-    EndpointType,
-    IDomainName,
-    IResource,
-    MockIntegration,
-    RestApi as RestApiBase
-} from "aws-cdk-lib/aws-apigateway";
-import {DeployStack} from "./DeployStack"
-import {ICorsConfig} from "./ICorsConfig";
-import {Duration, Size} from "aws-cdk-lib";
-import {Effect, Policy, PolicyStatement, Role} from "aws-cdk-lib/aws-iam";
-
-interface IRestApiConfig {
-    cors?: ICorsConfig,
-    allowCredentials: boolean
-}
-
-interface IBasePathMappingConfig {
-    domain?: IDomainName,
-    domainName?: string,
-    hostedZoneId?: string
-}
-
-interface IResourceNode {
-    children: { [key: string]: IResourceNode }
-    node: IResource
-}
-
-const DEFAULT_EXPOSE_HEADERS = ['Date']
-
-export class RestApi extends RestApiBase {
-    _id: string
-    _tree: IResourceNode
-
-
-    constructor(stack: DeployStack, id: string, props: IRestApiConfig) {
-        const {stage} = stack
-
-        console.log('Defining Rest API', stack.genId(id, 'api'))
-
-        const cors: ICorsConfig = props.cors || {}
-        const allowOrigins: string[] = Array.isArray(cors.allowOrigin) ? cors.allowOrigin : [cors.allowOrigin || '*']
-        super(stack, stack.genId(id, 'api'), {
-            restApiName: stack.genName('api'),
-            deploy: true,
-            deployOptions: {
-                stageName: stage,
-                tracingEnabled: true
-            },
-            minCompressionSize: Size.bytes(1000),
-            endpointConfiguration: {
-                types: [EndpointType.EDGE]
-            },
-            defaultCorsPreflightOptions: {
-                allowHeaders: ['*'],
-                allowMethods: ['*'],
-                allowCredentials: props.allowCredentials,
-                allowOrigins,
-                maxAge: Duration.seconds(cors.maxAge || 86400),
-                exposeHeaders: cors.exposeHeaders || DEFAULT_EXPOSE_HEADERS
-            }
-        })
-        this._id = id
-
-        // APIs MUST have at least one endpoint, so this will give it one
-        console.log('Adding health endpoint', '/health')
-        const health = this.root.addResource('health')
-        health.addMethod("GET", new MockIntegration({
-            requestTemplates: {
-                "application/json": "{\"statusCode\": 200}"
-            },
-            integrationResponses: [{
-                statusCode: '200',
-                contentHandling: ContentHandling.CONVERT_TO_TEXT,
-                responseTemplates: {
-                    'application/json': `
-##  See http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
-##  This template will pass through all parameters including path, querystring, header, stage variables, and context through to the integration endpoint via the body/payload
-#set($allParams = $input.params())
-{
-"body-json" : $input.json('$'),
-"params" : {
-#foreach($type in $allParams.keySet())
-    #set($params = $allParams.get($type))
-"$type" : {
-    #foreach($paramName in $params.keySet())
-    "$paramName" : "$util.escapeJavaScript($params.get($paramName))"
-        #if($foreach.hasNext),#end
-    #end
-}
-    #if($foreach.hasNext),#end
-#end
-},
-"stage-variables" : {
-#foreach($key in $stageVariables.keySet())
-"$key" : "$util.escapeJavaScript($stageVariables.get($key))"
-    #if($foreach.hasNext),#end
-#end
-},
-"context" : {
-    "account-id" : "$context.identity.accountId",
-    "api-id" : "$context.apiId",
-    "api-key" : "$context.identity.apiKey",
-    "authorizer-principal-id" : "$context.authorizer.principalId",
-    "caller" : "$context.identity.caller",
-    "cognito-authentication-provider" : "$context.identity.cognitoAuthenticationProvider",
-    "cognito-authentication-type" : "$context.identity.cognitoAuthenticationType",
-    "cognito-identity-id" : "$context.identity.cognitoIdentityId",
-    "cognito-identity-pool-id" : "$context.identity.cognitoIdentityPoolId",
-    "http-method" : "$context.httpMethod",
-    "stage" : "$context.stage",
-    "source-ip" : "$context.identity.sourceIp",
-    "user" : "$context.identity.user",
-    "user-agent" : "$context.identity.userAgent",
-    "user-arn" : "$context.identity.userArn",
-    "request-id" : "$context.requestId",
-    "resource-id" : "$context.resourceId",
-    "resource-path" : "$context.resourcePath"
-    }
-}`
-                }
-            }]
-        }), {
-            methodResponses: [{statusCode: "200"}]
-        })
-
-        this._tree = {node: this.root, children: {}}
-    }
-
-    addBasePathMapping(stack: DeployStack, config: IBasePathMappingConfig) {
-        let domain = config.domain
-        if (!domain && config.domainName && config.hostedZoneId) {
-            domain = DomainName.fromDomainNameAttributes(stack, stack.genName('domain-name'), {
-                domainName: config.domainName,
-                domainNameAliasHostedZoneId: config.hostedZoneId,
-                domainNameAliasTarget: this.restApiRootResourceId
-            })
-        }
-        if (!domain) throw new Error('Missing Domain Configuration For Base Path Mapping')
-
-        new BasePathMapping(stack, stack.genId(this._id, 'base-path-mapping'), {
-            domainName: domain,
-            stage: this.deploymentStage,
-            restApi: this,
-            basePath: this._id
-        })
-    }
-
-    addAuthorizedRole(stack: DeployStack, roleArn: string): PolicyStatement {
-        const policyStatement = new PolicyStatement({
-            effect: Effect.ALLOW,
-            actions: ['execute-api:Invoke']
-        })
-
-        const authRole = Role.fromRoleArn(stack, stack.genId('authenticated-role'), roleArn)
-        authRole.attachInlinePolicy(new Policy(stack, stack.genId('api-access-policy'), {
-            statements: [policyStatement]
-        }))
-        return policyStatement;
-    }
-
-    path(uri: string): IResource {
-        const {node} = uri.split('/')
-            .filter(path => !!path)
-            .reduce((resource, path) => {
-                if (!resource.children[path]) {
-                    resource.children[path] = {
-                        children: {},
-                        node: resource.node.addResource(path)
-                    }
-                }
-                return resource.children[path];
-            }, this._tree);
-
-        return node
-    }
-}

package/src/Role.ts

@@ -1,165 +0,0 @@
-import {FederatedPrincipal, IPrincipal, Role as CdkRole} from "aws-cdk-lib/aws-iam";
-import {Duration} from "aws-cdk-lib";
-import {Output} from './Output'
-import {DeployStack} from "./DeployStack";
-import {IManagedPolicy} from "aws-cdk-lib/aws-iam/lib/managed-policy";
-import {PolicyDocument} from "aws-cdk-lib/aws-iam/lib/policy-document";
-
-interface IRoleProps {
-    identityPool: string,
-    amr: string,
-    /**
-     * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`) which can assume this role.
-     *
-     * You can later modify the assume role policy document by accessing it via
-     * the `assumeRolePolicy` property.
-     *
-     * @stability stable
-     */
-    assumedBy?: IPrincipal,
-
-    /**
-     * (deprecated) ID that the role assumer needs to provide when assuming this role.
-     *
-     * If the configured and provided external IDs do not match, the
-     * AssumeRole operation will fail.
-     *
-     * @default No external ID required
-     * @deprecated see {@link externalIds}
-     */
-    readonly externalId?: string;
-    /**
-     * List of IDs that the role assumer needs to provide one of when assuming this role.
-     *
-     * If the configured and provided external IDs do not match, the
-     * AssumeRole operation will fail.
-     *
-     * @default No external ID required
-     * @stability stable
-     */
-    readonly externalIds?: string[];
-    /**
-     * A list of managed policies associated with this role.
-     *
-     * You can add managed policies later using
-     * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.
-     *
-     * @default - No managed policies.
-     * @stability stable
-     */
-    readonly managedPolicies?: IManagedPolicy[];
-    /**
-     * A list of named policies to inline into this role.
-     *
-     * These policies will be
-     * created with the role, whereas those added by ``addToPolicy`` are added
-     * using a separate CloudFormation resource (allowing a way around circular
-     * dependencies that could otherwise be introduced).
-     *
-     * @default - No policy is inlined in the Role resource.
-     * @stability stable
-     */
-    readonly inlinePolicies?: {
-        [name: string]: PolicyDocument;
-    };
-    /**
-     * The path associated with this role.
-     *
-     * For information about IAM paths, see
-     * Friendly Names and Paths in IAM User Guide.
-     *
-     * @default /
-     * @stability stable
-     */
-    readonly path?: string;
-    /**
-     * AWS supports permissions boundaries for IAM entities (users or roles).
-     *
-     * A permissions boundary is an advanced feature for using a managed policy
-     * to set the maximum permissions that an identity-based policy can grant to
-     * an IAM entity. An entity's permissions boundary allows it to perform only
-     * the actions that are allowed by both its identity-based policies and its
-     * permissions boundaries.
-     *
-     * @default - No permissions boundary.
-     * @stability stable
-     * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html
-     */
-    readonly permissionsBoundary?: IManagedPolicy;
-    /**
-     * A name for the IAM role.
-     *
-     * For valid values, see the RoleName parameter for
-     * the CreateRole action in the IAM API Reference.
-     *
-     * IMPORTANT: If you specify a name, you cannot perform updates that require
-     * replacement of this resource. You can perform updates that require no or
-     * some interruption. If you must replace the resource, specify a new name.
-     *
-     * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to
-     * acknowledge your template's capabilities. For more information, see
-     * Acknowledging IAM Resources in AWS CloudFormation Templates.
-     *
-     * @default - AWS CloudFormation generates a unique physical ID and uses that ID
-     * for the role name.
-     * @stability stable
-     */
-    readonly roleName?: string;
-    /**
-     * The maximum session duration that you want to set for the specified role.
-     *
-     * This setting can have a value from 1 hour (3600sec) to 12 (43200sec) hours.
-     *
-     * Anyone who assumes the role from the AWS CLI or API can use the
-     * DurationSeconds API parameter or the duration-seconds CLI parameter to
-     * request a longer session. The MaxSessionDuration setting determines the
-     * maximum duration that can be requested using the DurationSeconds
-     * parameter.
-     *
-     * If users don't specify a value for the DurationSeconds parameter, their
-     * security credentials are valid for one hour by default. This applies when
-     * you use the AssumeRole* API operations or the assume-role* CLI operations
-     * but does not apply when you use those operations to create a console URL.
-     *
-     * @default Duration.hours(1)
-     * @stability stable
-     * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html
-     */
-    readonly maxSessionDuration?: Duration;
-    /**
-     * A description of the role.
-     *
-     * It can be up to 1000 characters long.
-     *
-     * @default - No description.
-     * @stability stable
-     */
-    readonly description?: string;
-}
-
-export class Role extends CdkRole {
-    constructor(stack: DeployStack, id: string, props: IRoleProps) {
-        console.log('Defining Role', stack.genId(id))
-        if (!props.assumedBy) {
-            props.assumedBy = new FederatedPrincipal(
-                'cognito-identity.amazonaws.com',
-                {
-                    StringEquals: {
-                        'cognito-identity.amazonaws.com:aud': props.identityPool
-                    },
-                    "ForAnyValue:StringLike": {
-                        'cognito-identity.amazonaws.com:amr': props.amr
-                    }
-                },
-                'sts:AssumeRoleWithWebIdentity'
-            )
-        }
-
-        super(stack, stack.genId(id), {
-            ...props,
-            roleName: stack.genName(props.roleName || id),
-            assumedBy: props.assumedBy
-        })
-        new Output(stack, `${id}-arn`, this.roleArn)
-    }
-}

package/src/SsmParameter.ts

@@ -1,47 +0,0 @@
-import {DeployStack} from "./DeployStack";
-import {IStringParameter, StringParameter} from "aws-cdk-lib/aws-ssm";
-import {Effect, IGrantable, PolicyStatement} from "aws-cdk-lib/aws-iam";
-import {IKey} from "aws-cdk-lib/aws-kms";
-
-const paramCache: { [name: string]: IStringParameter } = {}
-
-interface SsmParameterOptions {
-    decryptWithKey?: IKey
-}
-
-export class SsmParameter {
-    parameterName: string
-    parameterArn: string
-    decryptWithKey?: IKey
-    _stack: DeployStack
-
-    constructor(stack: DeployStack, name: string, options?: SsmParameterOptions) {
-        if (name[0] !== '/') name = '/' + name
-        this.parameterName = `/${stack.name}${name}`;
-        this.parameterArn = `arn:aws:ssm:${stack.region}:${stack.account}:parameter${this.parameterName}`
-        this._stack = stack;
-        this.decryptWithKey = options?.decryptWithKey
-    }
-
-    grantRead(grantee: IGrantable) {
-        grantee.grantPrincipal.addToPrincipalPolicy(new PolicyStatement({
-            effect: Effect.ALLOW,
-            actions: ['ssm:GetParameter'],
-            resources: [this.parameterArn]
-        }))
-        if (this.decryptWithKey) {
-            this.decryptWithKey.grantDecrypt(grantee)
-        }
-    }
-
-    get stringValue() {
-        return this.getParameter().stringValue
-    }
-
-    getParameter() {
-        if (!paramCache[this.parameterArn]) {
-            paramCache[this.parameterArn] = StringParameter.fromStringParameterName(this._stack, this._stack.genId(this.parameterName.substring(1).replace('/', '_')), this.parameterName)
-        }
-        return paramCache[this.parameterArn]
-    }
-}

package/src/StaticWebSite.ts

@@ -1,99 +0,0 @@
-import {RemovalPolicy} from "aws-cdk-lib/core";
-import {Output} from './Output'
-import {DeployStack} from "./DeployStack";
-import {execSync} from "child_process";
-import * as fs from 'fs-extra'
-import * as path from 'path'
-import {Bucket} from "aws-cdk-lib/aws-s3"
-import {BucketDeployment, Source} from "aws-cdk-lib/aws-s3-deployment"
-import ApiCertificate from "./ApiCertificate";
-import {
-    CloudFrontAllowedMethods,
-    CloudFrontWebDistribution,
-    OriginAccessIdentity,
-    SSLMethod,
-    ViewerCertificate,
-    ViewerProtocolPolicy
-} from "aws-cdk-lib/aws-cloudfront"
-import IDomainConfig from "./IDomainConfig";
-import {PolicyStatement} from "aws-cdk-lib/aws-iam";
-import {ARecord, RecordTarget} from "aws-cdk-lib/aws-route53";
-import {CloudFrontTarget} from "aws-cdk-lib/aws-route53-targets";
-
-interface StaticWebSiteConfig {
-    srcDir?: string,
-    domain: IDomainConfig,
-    env: NodeJS.ProcessEnv
-}
-
-export class StaticWebSite {
-    constructor(stack: DeployStack, id: string, props: StaticWebSiteConfig) {
-        console.log('Deploying Static Web Site', id)
-        const srcDir = path.resolve("../src/", props.srcDir || '')
-        const buildDir = path.resolve("../dist/", props.srcDir || '')
-
-        console.log('Installing Prod Dependencies', id)
-        execSync('npm i --production --quiet', {
-            cwd: srcDir
-        })
-        console.log('Building UI Source', id)
-        execSync('npm run export', {
-            cwd: srcDir,
-            //env: props.env
-        })
-        fs.copySync(path.resolve(srcDir, "./out"), buildDir);
-
-        console.log('Creating HTTPS Certificate', id + '-certificate')
-        const certificate = new ApiCertificate(stack, id + '-certificate', props.domain);
-        console.log('Deploying Site Content Bucket', stack.genId(id, "content-bucket"))
-        const s3BucketSource = new Bucket(stack, stack.genId(id, "content-bucket"), {
-            bucketName: certificate.domain,
-            websiteIndexDocument: "index.html",
-            websiteErrorDocument: "error.html",
-            publicReadAccess: true,
-            removalPolicy: RemovalPolicy.DESTROY,
-            autoDeleteObjects: true
-        });
-        new Output(stack, `${id}-content-bucket`, s3BucketSource.bucketName);
-
-        const cloudFrontPolicy = new PolicyStatement({
-            actions: ['s3:GetBucket*', 's3:GetObject*', 's3:List*'],
-            resources: [s3BucketSource.bucketArn, s3BucketSource.bucketArn + '/*'],
-        })
-
-        new BucketDeployment(stack, stack.genId(id, 'bucket-deployment'), {
-            sources: [Source.asset(buildDir)],
-            destinationBucket: s3BucketSource
-        })
-        const originAccessIdentity = new OriginAccessIdentity(stack, "WebsiteOAI");
-         cloudFrontPolicy.addArnPrincipal(originAccessIdentity.cloudFrontOriginAccessIdentityS3CanonicalUserId)
-
-        const distro = new CloudFrontWebDistribution(stack, stack.genId(id, 'cloudfront-web-distribution'), {
-            enabled: true,
-            //priceClass:
-             originConfigs: [{
-                 s3OriginSource: {
-                     s3BucketSource,
-                     originAccessIdentity
-                 },
-                 behaviors: [{
-                     allowedMethods: CloudFrontAllowedMethods.GET_HEAD_OPTIONS,
-                     isDefaultBehavior: true
-                 }]
-             }],
-            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-            viewerCertificate: ViewerCertificate.fromAcmCertificate(certificate, {
-                aliases: [certificate.domain],
-                sslMethod: SSLMethod.SNI
-            })
-        })
-        new Output(stack, `${id}-base-url`, "https://" + certificate.domain);
-
-        console.log('Setting Route53 A-Name Record', props.domain.domainName)
-         new ARecord(stack, stack.genId('alias'), {
-             zone: certificate.hostedZone,
-             recordName: certificate.domain,
-             target: RecordTarget.fromAlias(new CloudFrontTarget(distro))
-         })
-    }
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-export {ApiCertificate} from "./ApiCertificate";
-export {CognitoApiGatewayAuthorizer} from "./CognitoApiGatewayAuthorizer";
-export {DeployStack} from "./DeployStack";
-export {DynamoDbTable} from "./DynamoDbTable";
-export {FunctionIntegration} from "./FunctionIntegration";
-export {IHostedZoneConfig} from "./IHostedZoneConfig";
-export {IDomainConfig} from "./IDomainConfig";
-export {IStackArguments} from "./IStackArguments";
-export {NodeJsLambda} from "./NodeJsLambda";
-export {NodeJsLambdaLayer} from "./NodeJsLambdaLayer";
-export {Output} from "./Output";
-export {RestApi} from "./RestApi";
-export {Role} from "./Role";
-export {SsmParameter} from "./SsmParameter";
-export {StaticWebSite} from "./StaticWebSite";

package/src/methods/apply-honeycomb-to-lambda.ts

@@ -1,22 +0,0 @@
-import {FunctionProps, ILayerVersion, LayerVersion} from "aws-cdk-lib/aws-lambda"
-import {DeployStack} from "../DeployStack";
-import {SsmParameter} from "../SsmParameter";
-
-let honeyCombLayer: ILayerVersion
-export function applyHoneycombToLambda(stack: DeployStack, props: FunctionProps): FunctionProps {
-    if (!honeyCombLayer) honeyCombLayer = LayerVersion.fromLayerVersionArn(stack, stack.genId('hc-layer'), `arn:aws:lambda:${stack.region}:702835727665:layer:honeycomb-lambda-extension-x86_64-v11-1-1:1`)
-
-    const layers = props.layers ? [...props.layers] : []
-    const environment = props.environment || {}
-
-    layers.push(honeyCombLayer)
-    environment.LIBHONEY_API_KEY = new SsmParameter(stack, `/honeycomb/api-key`).stringValue
-    environment.LIBHONEY_DATASET =new SsmParameter(stack, `/honeycomb/dataset`).stringValue
-    environment.LOGS_API_DISABLE_PLATFORM_MSGS = "true"
-
-    return {
-        ...props,
-        layers,
-        environment
-    }
-}

package/src/methods/build-node-source.ts

@@ -1,97 +0,0 @@
-import * as path from 'path'
-import * as fse from "fs-extra";
-import * as fs from "fs";
-import {execSync} from "child_process";
-import {generateHash, HashResult} from "./generate-hash"
-import {getBuildDirectory, getSourceDirectory} from './get-source-directory'
-import duration from "./duration";
-import emptyDirSync from './empty-directory'
-import {IIgnoreOptions} from "./walk-directory";
-
-const distributionRoot = path.resolve(process.cwd(), "../dist")
-const hashRoot = path.join(distributionRoot, "hash")
-fse.ensureDirSync(hashRoot)
-
-export const defaultIgnore: IIgnoreOptions = {
-    included: (p: fs.Dirent): boolean => {
-        return !p.name.startsWith(".") &&
-            !p.name.endsWith(".md") &&
-            !p.name.includes(".test.") &&
-            p.name !== 'package-lock.json';
-    },
-    childrenIncluded: (p: fs.Dirent): boolean => {
-        return p.name === "node_modules";
-    }
-} as IIgnoreOptions
-
-interface IBuildOptions {
-    dir?: string,
-    ignore?: IIgnoreOptions
-}
-
-export function buildNodeSource(type: string, id: string, options: IBuildOptions = {}): {
-    buildDir: string,
-    moduleChanged: boolean,
-    packageChanged: boolean,
-    sourceChanged: boolean
-} {
-    const {dir = ''} = options
-    const ignore = {
-        ...defaultIgnore, ...options.ignore
-    }
-    const srcDir = getSourceDirectory(type, id)
-    const buildDir = getBuildDirectory(type, id)
-    const hashFilePath = path.join(hashRoot, `${type}-${id}-hash.txt`)
-
-    const folderExists = fs.existsSync(buildDir)
-    const hashFileExists = folderExists && fse.existsSync(hashFilePath)
-    const prevHash: HashResult = (hashFileExists ? fse.readJsonSync(hashFilePath) : {}) as HashResult
-    const hash: string = generateHash(srcDir, {ignore});
-    const nextHash: HashResult = JSON.parse(generateHash(srcDir, {ignore})) as HashResult;
-    const moduleChanged = JSON.stringify(prevHash, null, '\t') !== hash;
-    let packageChanged = false, sourceChanged = false;
-
-    if (moduleChanged) {
-        const prevPackageHash = findPackageHash(prevHash);
-        const packageHash = findPackageHash(nextHash);
-        packageChanged = prevPackageHash !== packageHash;
-
-        sourceChanged = sourceWasUpdated(prevHash, nextHash);
-        if (sourceChanged) {
-            const rmComplete = duration()
-            if (folderExists) emptyDirSync(buildDir, {childrenExcluded: folder => folder.name === 'node_modules'})
-            console.log('Cleanup Duration (ms)', rmComplete())
-
-            const copyComplete = duration()
-            fse.copySync(srcDir, buildDir, {
-                filter: src => !~src.indexOf("node_modules") && !src.endsWith('.test.js')
-            });
-            console.log('Copy Duration (ms)', copyComplete())
-        }
-
-        if (packageChanged) {
-            const installComplete = duration()
-            execSync("npm i --omit=dev --omit=optional --omit=peer --quite", {
-                cwd: dir ? path.resolve(buildDir, dir) : buildDir
-            });
-            console.log('NPM Install Duration (ms)', installComplete())
-        }
-        fs.writeFileSync(hashFilePath, hash);
-    }
-
-    return {buildDir, packageChanged, sourceChanged, moduleChanged}
-}
-
-function findPackageHash(hash: HashResult): string | undefined {
-    return hash?.children?.find(file => file.name === 'package.json')?.hash;
-}
-
-function sourceWasUpdated(prevHash: HashResult, nextHash: HashResult): boolean {
-    const fileCountChanged = prevHash.children?.length != nextHash.children?.length
-    const updatedItem = prevHash.children?.find(prevFile => {
-        const nextFile = nextHash.children?.find(f => f.name = prevFile.name);
-        return prevFile.name !== 'package.json' && (!nextFile || nextFile.hash !== prevFile.hash)
-    });
-
-    return fileCountChanged || !!updatedItem
-}

package/src/methods/duration.ts

@@ -1,24 +0,0 @@
-const hrDuration = () => {
-    const startTime: [number, number] = process.hrtime();
-    const onEnd = function duration(): number {
-        const hrTime:[number, number] = process.hrtime(startTime);
-        return hrTime[0] * 1000 + hrTime[1] / 1000000;
-    };
-    onEnd.time = startTime;
-
-    return onEnd;
-};
-const msDuration = () => {
-    const startTime: number = Date.now();
-    const onEnd = function duration(): number {
-        return Date.now() - startTime;
-    };
-    onEnd.time = startTime;
-
-    return onEnd;
-};
-
-// @ts-ignore
-const duration= process.hrtime ? hrDuration : msDuration
-
-export default duration

package/src/methods/empty-directory.ts

@@ -1,19 +0,0 @@
-import * as fse from "fs-extra";
-import duration from "./duration";
-import walkDirectory, {DirentExtended, IIgnoreOptions} from "./walk-directory";
-
-export default function emptyDirSync(parentFolder: string, options: IIgnoreOptions) {
-    const rmComplete = duration()
-    const files = walkDirectory(parentFolder, options);
-
-    files
-        .forEach((file:DirentExtended) => {
-            try {
-                fse.removeSync(file.fullpath());
-                console.log('Deleted file:', file.fullpath());
-            } catch (err) {
-                console.error('Error deleting file:', err);
-            }
-        });
-    console.log('Empty Directory Complete (ms)', parentFolder, rmComplete())
-}