@smythos/sre 1.6.1 → 1.6.8

package/src/helpers/OpenApiParser.helper.ts

@@ -1,150 +1,150 @@
-import axios from 'axios';
-import yaml from 'js-yaml';
-
-import { REQUEST_METHODS } from '../constants';
-
-// * We need a couple of packages to resolve references in the OpenAPI specification
-//FIXME : YAML support temporarly disabled to allow executable packaging
-//import SwaggerParser from '@apidevtools/swagger-parser';
-//import $RefParser from '@apidevtools/json-schema-ref-parser';
-//import { JSONSchema } from '@apidevtools/json-schema-ref-parser/dist/lib/types';
-
-//const swaggerParser = new SwaggerParser();
-
-type JSONSchema = Record<string, any>;
-
-/**
- * Utility function to resolve $ref values within a schema.
- * @param schema The schema containing potential $ref values.
- * @param root The root schema for reference resolution.
- * @returns The dereferenced schema.
- */
-const dereferenceSchema = async (schema: any, root: any = schema): Promise<any> => {
-    if (typeof schema !== 'object' || schema === null) {
-        return schema;
-    }
-
-    if (schema.$ref) {
-        const ref = schema.$ref;
-        const path = ref.replace(/^#\//, '').split('/'); // Remove the initial '#/' and split the path
-        let resolved = root;
-        for (const segment of path) {
-            if (resolved[segment] === undefined) {
-                throw new Error(`Could not resolve $ref: ${ref}`);
-            }
-            resolved = resolved[segment];
-        }
-        return dereferenceSchema(resolved, root); // Recursively dereference
-    }
-
-    // Recursively resolve all properties and items
-    if (Array.isArray(schema)) {
-        return Promise.all(schema.map((item) => dereferenceSchema(item, root)));
-    }
-
-    const result: any = {};
-    for (const key of Object.keys(schema)) {
-        result[key] = await dereferenceSchema(schema[key], root);
-    }
-    return result;
-};
-
-export class OpenAPIParser {
-    static mapReqMethods(paths: Array<Record<string, any>>): Map<string, any> {
-        const methods = new Map();
-
-        for (const path in paths) {
-            const pathData = paths[path];
-
-            for (const method in pathData) {
-                const data = pathData[method];
-
-                if (REQUEST_METHODS.includes(method.toUpperCase())) {
-                    methods.set(data?.operationId, method);
-                }
-            }
-        }
-
-        return methods;
-    }
-    static mapEndpoints(paths: Array<Record<string, any>>): Map<string, any> {
-        const operationIds = new Map();
-
-        for (const path in paths) {
-            const pathData = paths[path];
-
-            // it's possible we have multiple methods for a single path
-            for (const method in pathData) {
-                const data = pathData[method];
-
-                if (REQUEST_METHODS.includes(method.toUpperCase())) {
-                    operationIds.set(data?.operationId, path);
-                }
-            }
-        }
-
-        return operationIds;
-    }
-
-    // static async yamlToJson(yamlData: string): Promise<JSONSchema> {
-    //     const data = yaml.load(yamlData);
-    //     //FIXME : YAML support temporarly disabled to allow executable packaging
-    //     const schema = await $RefParser.dereference(data);
-    //     //const schema: any = {};
-
-    //     return schema;
-    // }
-
-    static async yamlToJson(yamlData: string): Promise<JSONSchema> {
-        const data = yaml.load(yamlData);
-        const schema = await dereferenceSchema(data);
-        return schema;
-    }
-
-    // static async getJson(data: string | Record<string, any>): Promise<Record<string, any>> {
-    //     try {
-    //         let _data = data;
-    //         if (typeof data === 'string') {
-    //             _data = JSON.parse(_data as string);
-    //         }
-    //         //FIXME : YAML support temporarly disabled to allow executable packaging
-    //         const result = swaggerParser.dereference(_data as any);
-    //         //const result: any = {};
-    //         return result;
-    //     } catch (error) {
-    //         try {
-    //             return OpenAPIParser.yamlToJson(data as string);
-    //         } catch (error) {
-    //             throw new Error('Invalid OpenAPI specification data format');
-    //         }
-    //     }
-    // }
-
-    static async getJson(data: string | Record<string, any>): Promise<Record<string, any>> {
-        try {
-            let parsedData = data;
-            if (typeof data === 'string') {
-                parsedData = JSON.parse(data);
-            }
-
-            return await dereferenceSchema(parsedData);
-        } catch (error) {
-            try {
-                // Fallback to handle YAML data
-                return await OpenAPIParser.yamlToJson(data as string);
-            } catch (innerError) {
-                throw new Error('Invalid OpenAPI specification or JSON data format');
-            }
-        }
-    }
-    static async getJsonFromUrl(url: string): Promise<Record<string, any>> {
-        const response = await axios.get(url);
-        const data = response.data;
-
-        return OpenAPIParser.getJson(data);
-    }
-
-    static isValidOpenAPI(data: Record<string, any>): boolean {
-        return data?.openapi && data?.paths && data?.servers;
-    }
-}
+import axios from 'axios';
+import yaml from 'js-yaml';
+
+import { REQUEST_METHODS } from '../constants';
+
+// * We need a couple of packages to resolve references in the OpenAPI specification
+//FIXME : YAML support temporarly disabled to allow executable packaging
+//import SwaggerParser from '@apidevtools/swagger-parser';
+//import $RefParser from '@apidevtools/json-schema-ref-parser';
+//import { JSONSchema } from '@apidevtools/json-schema-ref-parser/dist/lib/types';
+
+//const swaggerParser = new SwaggerParser();
+
+type JSONSchema = Record<string, any>;
+
+/**
+ * Utility function to resolve $ref values within a schema.
+ * @param schema The schema containing potential $ref values.
+ * @param root The root schema for reference resolution.
+ * @returns The dereferenced schema.
+ */
+const dereferenceSchema = async (schema: any, root: any = schema): Promise<any> => {
+    if (typeof schema !== 'object' || schema === null) {
+        return schema;
+    }
+
+    if (schema.$ref) {
+        const ref = schema.$ref;
+        const path = ref.replace(/^#\//, '').split('/'); // Remove the initial '#/' and split the path
+        let resolved = root;
+        for (const segment of path) {
+            if (resolved[segment] === undefined) {
+                throw new Error(`Could not resolve $ref: ${ref}`);
+            }
+            resolved = resolved[segment];
+        }
+        return dereferenceSchema(resolved, root); // Recursively dereference
+    }
+
+    // Recursively resolve all properties and items
+    if (Array.isArray(schema)) {
+        return Promise.all(schema.map((item) => dereferenceSchema(item, root)));
+    }
+
+    const result: any = {};
+    for (const key of Object.keys(schema)) {
+        result[key] = await dereferenceSchema(schema[key], root);
+    }
+    return result;
+};
+
+export class OpenAPIParser {
+    static mapReqMethods(paths: Array<Record<string, any>>): Map<string, any> {
+        const methods = new Map();
+
+        for (const path in paths) {
+            const pathData = paths[path];
+
+            for (const method in pathData) {
+                const data = pathData[method];
+
+                if (REQUEST_METHODS.includes(method.toUpperCase())) {
+                    methods.set(data?.operationId, method);
+                }
+            }
+        }
+
+        return methods;
+    }
+    static mapEndpoints(paths: Array<Record<string, any>>): Map<string, any> {
+        const operationIds = new Map();
+
+        for (const path in paths) {
+            const pathData = paths[path];
+
+            // it's possible we have multiple methods for a single path
+            for (const method in pathData) {
+                const data = pathData[method];
+
+                if (REQUEST_METHODS.includes(method.toUpperCase())) {
+                    operationIds.set(data?.operationId, path);
+                }
+            }
+        }
+
+        return operationIds;
+    }
+
+    // static async yamlToJson(yamlData: string): Promise<JSONSchema> {
+    //     const data = yaml.load(yamlData);
+    //     //FIXME : YAML support temporarly disabled to allow executable packaging
+    //     const schema = await $RefParser.dereference(data);
+    //     //const schema: any = {};
+
+    //     return schema;
+    // }
+
+    static async yamlToJson(yamlData: string): Promise<JSONSchema> {
+        const data = yaml.load(yamlData);
+        const schema = await dereferenceSchema(data);
+        return schema;
+    }
+
+    // static async getJson(data: string | Record<string, any>): Promise<Record<string, any>> {
+    //     try {
+    //         let _data = data;
+    //         if (typeof data === 'string') {
+    //             _data = JSON.parse(_data as string);
+    //         }
+    //         //FIXME : YAML support temporarly disabled to allow executable packaging
+    //         const result = swaggerParser.dereference(_data as any);
+    //         //const result: any = {};
+    //         return result;
+    //     } catch (error) {
+    //         try {
+    //             return OpenAPIParser.yamlToJson(data as string);
+    //         } catch (error) {
+    //             throw new Error('Invalid OpenAPI specification data format');
+    //         }
+    //     }
+    // }
+
+    static async getJson(data: string | Record<string, any>): Promise<Record<string, any>> {
+        try {
+            let parsedData = data;
+            if (typeof data === 'string') {
+                parsedData = JSON.parse(data);
+            }
+
+            return await dereferenceSchema(parsedData);
+        } catch (error) {
+            try {
+                // Fallback to handle YAML data
+                return await OpenAPIParser.yamlToJson(data as string);
+            } catch (innerError) {
+                throw new Error('Invalid OpenAPI specification or JSON data format');
+            }
+        }
+    }
+    static async getJsonFromUrl(url: string): Promise<Record<string, any>> {
+        const response = await axios.get(url);
+        const data = response.data;
+
+        return OpenAPIParser.getJson(data);
+    }
+
+    static isValidOpenAPI(data: Record<string, any>): boolean {
+        return data?.openapi && data?.paths && data?.servers;
+    }
+}

package/src/helpers/S3Cache.helper.ts

@@ -1,147 +1,147 @@
-import { GetBucketLifecycleConfigurationCommandOutput, PutBucketLifecycleConfigurationCommand } from '@aws-sdk/client-s3';
-
-import { GetBucketLifecycleConfigurationCommand } from '@aws-sdk/client-s3';
-import { S3Client } from '@aws-sdk/client-s3';
-import { Logger } from '@sre/helpers/Log.helper';
-const console = Logger('S3Cache');
-
-export function generateLifecycleRules() {
-    const rules = [];
-
-    // Add rules for 1-100 days
-    for (let i = 1; i < 100; i++) {
-        rules.push({
-            ID: `ExpireAfter${i}Days`,
-            Filter: {
-                // Prefix: '',
-                Tag: {
-                    Key: 'Expiry',
-                    Value: 'ExpireAfter' + i + 'Days',
-                },
-            },
-            Status: 'Enabled',
-            Expiration: { Days: i },
-        });
-    }
-
-    // Add rules for 110-1000 days with 10-day steps
-    for (let i = 100; i < 1000; i += 10) {
-        rules.push({
-            ID: `ExpireAfter${i}Days`,
-            Filter: {
-                // Prefix: '',
-                Tag: {
-                    Key: 'Expiry',
-                    Value: 'ExpireAfter' + i + 'Days',
-                },
-            },
-            Status: 'Enabled',
-            Expiration: { Days: i },
-        });
-    }
-
-    // Add rules for 1000-10000 days with 100-day steps
-    for (let i = 1000; i <= 10000; i += 100) {
-        rules.push({
-            ID: `ExpireAfter${i}Days`,
-            Filter: {
-                // Prefix: '',
-                Tag: {
-                    Key: 'Expiry',
-                    Value: 'ExpireAfter' + i + 'Days',
-                },
-            },
-            Status: 'Enabled',
-            Expiration: { Days: i },
-        });
-    }
-
-    return rules;
-}
-
-export function generateExpiryMetadata(expiryDays) {
-    let metadataValue;
-
-    if (expiryDays >= 1 && expiryDays < 100) {
-        metadataValue = `ExpireAfter${expiryDays}Days`;
-    } else if (expiryDays >= 100 && expiryDays < 1000) {
-        const roundedUpDays = Math.ceil(expiryDays / 10) * 10;
-        metadataValue = `ExpireAfter${roundedUpDays}Days`;
-    } else if (expiryDays >= 1000 && expiryDays <= 10000) {
-        const roundedUpDays = Math.ceil(expiryDays / 100) * 100;
-        metadataValue = `ExpireAfter${roundedUpDays}Days`;
-    } else {
-        throw new Error('Invalid expiry days. Please provide a valid expiry days value.');
-    }
-
-    return {
-        Key: 'Expiry',
-        Value: metadataValue,
-    };
-}
-
-export function getNonExistingRules(existingRules: any[], newRules: any[]) {
-    return newRules.filter((rule) => !existingRules.some((existingRule) => existingRule.ID === rule.ID));
-}
-
-export function ttlToExpiryDays(ttl: number) {
-    // seconds
-    return Math.ceil(ttl / (60 * 60 * 24));
-}
-
-export async function checkAndInstallLifecycleRules(bucketName: string, s3Client: S3Client) {
-    // Validate inputs
-    if (!bucketName || bucketName.trim() === '') {
-        throw new Error('Bucket name is required and cannot be empty');
-    }
-
-    if (!s3Client) {
-        throw new Error('S3Client is required');
-    }
-
-    console.log(`Checking lifecycle rules for bucket: ${bucketName}`);
-
-    try {
-        // Check existing lifecycle configuration
-        const getLifecycleCommand = new GetBucketLifecycleConfigurationCommand({ Bucket: bucketName });
-        const existingLifecycle: GetBucketLifecycleConfigurationCommandOutput = await s3Client.send(getLifecycleCommand);
-        const existingRules = existingLifecycle.Rules;
-        const newRules = generateLifecycleRules();
-        const nonExistingNewRules = getNonExistingRules(existingRules, newRules);
-        if (nonExistingNewRules.length > 0) {
-            const params = {
-                Bucket: bucketName,
-                LifecycleConfiguration: { Rules: [...existingRules, ...nonExistingNewRules] },
-            };
-            const putLifecycleCommand = new PutBucketLifecycleConfigurationCommand(params);
-            // Put the new lifecycle configuration
-            await s3Client.send(putLifecycleCommand);
-            console.log(`Added ${nonExistingNewRules.length} new lifecycle rules to bucket: ${bucketName}`);
-        } else {
-            console.log('Lifecycle configuration already exists');
-        }
-    } catch (error) {
-        if (error.code === 'NoSuchLifecycleConfiguration') {
-            console.log('No lifecycle configuration found. Creating new configuration...');
-
-            const lifecycleRules = generateLifecycleRules();
-
-            const params = {
-                Bucket: bucketName,
-                LifecycleConfiguration: { Rules: lifecycleRules },
-            };
-            const putLifecycleCommand = new PutBucketLifecycleConfigurationCommand(params);
-            // Put the new lifecycle configuration
-            await s3Client.send(putLifecycleCommand);
-            console.log('Lifecycle configuration created successfully.');
-        } else {
-            console.error('Error checking lifecycle configuration:', error);
-            console.error('Bucket name provided:', bucketName);
-            console.error('Error details:', {
-                name: error.name,
-                message: error.message,
-                code: error.code,
-            });
-        }
-    }
-}
+import { GetBucketLifecycleConfigurationCommandOutput, PutBucketLifecycleConfigurationCommand } from '@aws-sdk/client-s3';
+
+import { GetBucketLifecycleConfigurationCommand } from '@aws-sdk/client-s3';
+import { S3Client } from '@aws-sdk/client-s3';
+import { Logger } from '@sre/helpers/Log.helper';
+const console = Logger('S3Cache');
+
+export function generateLifecycleRules() {
+    const rules = [];
+
+    // Add rules for 1-100 days
+    for (let i = 1; i < 100; i++) {
+        rules.push({
+            ID: `ExpireAfter${i}Days`,
+            Filter: {
+                // Prefix: '',
+                Tag: {
+                    Key: 'Expiry',
+                    Value: 'ExpireAfter' + i + 'Days',
+                },
+            },
+            Status: 'Enabled',
+            Expiration: { Days: i },
+        });
+    }
+
+    // Add rules for 110-1000 days with 10-day steps
+    for (let i = 100; i < 1000; i += 10) {
+        rules.push({
+            ID: `ExpireAfter${i}Days`,
+            Filter: {
+                // Prefix: '',
+                Tag: {
+                    Key: 'Expiry',
+                    Value: 'ExpireAfter' + i + 'Days',
+                },
+            },
+            Status: 'Enabled',
+            Expiration: { Days: i },
+        });
+    }
+
+    // Add rules for 1000-10000 days with 100-day steps
+    for (let i = 1000; i <= 10000; i += 100) {
+        rules.push({
+            ID: `ExpireAfter${i}Days`,
+            Filter: {
+                // Prefix: '',
+                Tag: {
+                    Key: 'Expiry',
+                    Value: 'ExpireAfter' + i + 'Days',
+                },
+            },
+            Status: 'Enabled',
+            Expiration: { Days: i },
+        });
+    }
+
+    return rules;
+}
+
+export function generateExpiryMetadata(expiryDays) {
+    let metadataValue;
+
+    if (expiryDays >= 1 && expiryDays < 100) {
+        metadataValue = `ExpireAfter${expiryDays}Days`;
+    } else if (expiryDays >= 100 && expiryDays < 1000) {
+        const roundedUpDays = Math.ceil(expiryDays / 10) * 10;
+        metadataValue = `ExpireAfter${roundedUpDays}Days`;
+    } else if (expiryDays >= 1000 && expiryDays <= 10000) {
+        const roundedUpDays = Math.ceil(expiryDays / 100) * 100;
+        metadataValue = `ExpireAfter${roundedUpDays}Days`;
+    } else {
+        throw new Error('Invalid expiry days. Please provide a valid expiry days value.');
+    }
+
+    return {
+        Key: 'Expiry',
+        Value: metadataValue,
+    };
+}
+
+export function getNonExistingRules(existingRules: any[], newRules: any[]) {
+    return newRules.filter((rule) => !existingRules.some((existingRule) => existingRule.ID === rule.ID));
+}
+
+export function ttlToExpiryDays(ttl: number) {
+    // seconds
+    return Math.ceil(ttl / (60 * 60 * 24));
+}
+
+export async function checkAndInstallLifecycleRules(bucketName: string, s3Client: S3Client) {
+    // Validate inputs
+    if (!bucketName || bucketName.trim() === '') {
+        throw new Error('Bucket name is required and cannot be empty');
+    }
+
+    if (!s3Client) {
+        throw new Error('S3Client is required');
+    }
+
+    console.log(`Checking lifecycle rules for bucket: ${bucketName}`);
+
+    try {
+        // Check existing lifecycle configuration
+        const getLifecycleCommand = new GetBucketLifecycleConfigurationCommand({ Bucket: bucketName });
+        const existingLifecycle: GetBucketLifecycleConfigurationCommandOutput = await s3Client.send(getLifecycleCommand);
+        const existingRules = existingLifecycle.Rules;
+        const newRules = generateLifecycleRules();
+        const nonExistingNewRules = getNonExistingRules(existingRules, newRules);
+        if (nonExistingNewRules.length > 0) {
+            const params = {
+                Bucket: bucketName,
+                LifecycleConfiguration: { Rules: [...existingRules, ...nonExistingNewRules] },
+            };
+            const putLifecycleCommand = new PutBucketLifecycleConfigurationCommand(params);
+            // Put the new lifecycle configuration
+            await s3Client.send(putLifecycleCommand);
+            console.log(`Added ${nonExistingNewRules.length} new lifecycle rules to bucket: ${bucketName}`);
+        } else {
+            console.log('Lifecycle configuration already exists');
+        }
+    } catch (error) {
+        if (error.code === 'NoSuchLifecycleConfiguration') {
+            console.log('No lifecycle configuration found. Creating new configuration...');
+
+            const lifecycleRules = generateLifecycleRules();
+
+            const params = {
+                Bucket: bucketName,
+                LifecycleConfiguration: { Rules: lifecycleRules },
+            };
+            const putLifecycleCommand = new PutBucketLifecycleConfigurationCommand(params);
+            // Put the new lifecycle configuration
+            await s3Client.send(putLifecycleCommand);
+            console.log('Lifecycle configuration created successfully.');
+        } else {
+            console.error('Error checking lifecycle configuration:', error);
+            console.error('Bucket name provided:', bucketName);
+            console.error('Error details:', {
+                name: error.name,
+                message: error.message,
+                code: error.code,
+            });
+        }
+    }
+}

package/src/helpers/SmythURI.helper.ts

@@ -1,5 +1,5 @@
-export class SmythURI {
-    static agent(id: string): string {
-        return `smyth:agent:${id}`;
-    }
-}
+export class SmythURI {
+    static agent(id: string): string {
+        return `smyth:agent:${id}`;
+    }
+}