@trustify-da/trustify-da-javascript-client 0.2.4-ea-1

package/dist/src/oci_image/images.js

@@ -0,0 +1,263 @@
+import { PackageURL } from "packageurl-js";
+import { Platform } from "./platform.js";
+import { getImageDigests, getImagePlatform } from "./utils.js";
+/**
+* Helper class for parsing docker repository/image names:
+*
+* - If the first part before the slash contains a "." or a ":" it is considered to be a registry URL
+* - A last part starting with a ":" is considered to be a tag
+* - The rest is considered the repository name (which might be separated via slashes)
+*
+* Example of valid names:
+*
+* - consol/tomcat-8.0
+* - consol/tomcat-8.0:8.0.9
+* - docker.consol.de:5000/tomcat-8.0
+* - docker.consol.de:5000/jolokia/tomcat-8.0:8.0.9
+*/
+export class Image {
+    static NAME_COMPONENT_REGEXP = '[a-z0-9]+(?:(?:(?:[._]|__|[-]*)[a-z0-9]+)+)?';
+    static DOMAIN_COMPONENT_REGEXP = '(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])';
+    static NAME_COMP_REGEXP = new RegExp(this.NAME_COMPONENT_REGEXP);
+    static IMAGE_NAME_REGEXP = new RegExp(this.NAME_COMPONENT_REGEXP + '(?:(?:/' + this.NAME_COMPONENT_REGEXP + ')+)?');
+    static DOMAIN_REGEXP = new RegExp('^' + this.DOMAIN_COMPONENT_REGEXP + '(?:\\.' + this.DOMAIN_COMPONENT_REGEXP + ')*(?::[0-9]+)?$');
+    static TAG_REGEXP = new RegExp('^[\\w][\\w.-]{0,127}$');
+    static DIGEST_REGEXP = new RegExp('^sha256:[a-z0-9]{32,}$');
+    /**
+     *
+     * @param {string} fullName
+     * @param {string} [givenTag]
+     */
+    constructor(fullName, givenTag) {
+        this.repository = '';
+        this.registry = '';
+        this.tag = '';
+        this.digest = '';
+        this.user = '';
+        if (fullName == null) {
+            throw new Error('Image name must not be null');
+        }
+        // Set digest to null as default
+        this.digest = null;
+        // Check if digest is part of fullName
+        if (fullName.includes('@sha256')) {
+            const digestParts = fullName.split('@');
+            this.digest = digestParts[1];
+            fullName = digestParts[0];
+        }
+        // Check for tag
+        const tagPattern = /^(.+?)(?::([^:/]+))?$/;
+        const matcher = fullName.match(tagPattern);
+        if (!matcher) {
+            throw new Error(fullName + ' is not a proper image name ([registry/][repo][:port]');
+        }
+        this.tag = givenTag != null ? givenTag : matcher[2];
+        const rest = matcher[1];
+        this.parseComponentsBeforeTag(rest);
+        if (this.tag == null && this.digest == null) {
+            this.tag = 'latest';
+        }
+        this.doValidate();
+    }
+    /**
+    * @param {string[]} parts
+    * @returns {string}
+    */
+    joinTail(parts) {
+        let builder = '';
+        for (let i = 1; i < parts.length; i++) {
+            builder += parts[i];
+            if (i < parts.length - 1) {
+                builder += '/';
+            }
+        }
+        return builder;
+    }
+    /**
+    * @param {string} part
+    * @returns {boolean}
+    */
+    isRegistry(part) {
+        return part.includes('.') || part.includes(':');
+    }
+    /**
+    * @param {string} [optionalRegistry]
+    * @returns {string}
+    */
+    getNameWithoutTag(optionalRegistry) {
+        let ret = '';
+        if (this.registry != null || optionalRegistry != null) {
+            ret += (this.registry != null ? this.registry : optionalRegistry) + '/';
+        }
+        ret += this.repository;
+        return ret;
+    }
+    /**
+    * @param {string} [optionalRegistry]
+    * @returns {string}
+    */
+    getFullName(optionalRegistry) {
+        let fullName = this.getNameWithoutTag(optionalRegistry);
+        if (this.tag != null) {
+            fullName = fullName + ':' + this.tag;
+        }
+        if (this.digest != null) {
+            fullName = fullName + '@' + this.digest;
+        }
+        return fullName;
+    }
+    /**
+    * @returns {string}
+    */
+    getSimpleName() {
+        const prefix = this.user + '/';
+        return this.repository.startsWith(prefix) ? this.repository.substring(prefix.length) : this.repository;
+    }
+    /**
+    * @param {string} optionalRepository
+    * @returns {string}
+    */
+    getNameWithOptionalRepository(optionalRepository) {
+        if (optionalRepository != null) {
+            const simpleName = this.getFullName();
+            const simpleNameParts = simpleName.split('/');
+            if (simpleNameParts.length > 0) {
+                return optionalRepository + '/' + simpleNameParts[simpleNameParts.length - 1];
+            }
+        }
+        return this.getFullName();
+    }
+    doValidate() {
+        const errors = [];
+        const image = this.user != null ? this.repository.substring(this.user.length + 1) : this.repository;
+        /** @type {[[string, RegExp, string]]} */
+        const checks = [
+            ['registry', Image.DOMAIN_REGEXP, this.registry],
+            ['image', Image.IMAGE_NAME_REGEXP, image],
+            ['user', Image.NAME_COMP_REGEXP, this.user],
+            ['tag', Image.TAG_REGEXP, this.tag],
+            ['digest', Image.DIGEST_REGEXP, this.digest]
+        ];
+        for (const [name, pattern, value] of checks) {
+            if (value != null && !pattern.test(value)) {
+                errors.push(`${name} part '${value}' doesn't match allowed pattern '${pattern.source}'`);
+            }
+        }
+        if (errors.length > 0) {
+            const message = `Given Docker name '${this.getFullName()}' is invalid:\n` +
+                errors.map(error => `   * ${error}`).join('\n') +
+                '\nSee http://bit.ly/docker_image_fmt for more details';
+            throw new Error(message);
+        }
+    }
+    /**
+    * @param {string} rest
+    */
+    parseComponentsBeforeTag(rest) {
+        const parts = rest.split(/\s*\/\s*/);
+        if (parts.length === 1) {
+            this.registry = null;
+            this.user = null;
+            this.repository = parts[0];
+        }
+        else if (parts.length >= 2) {
+            if (this.isRegistry(parts[0])) {
+                this.registry = parts[0];
+                if (parts.length > 2) {
+                    this.user = parts[1];
+                    this.repository = this.joinTail(parts);
+                }
+                else {
+                    this.user = null;
+                    this.repository = parts[1];
+                }
+            }
+            else {
+                this.registry = null;
+                this.user = parts[0];
+                this.repository = rest;
+            }
+        }
+    }
+}
+export class ImageRef {
+    static OCI_TYPE = "oci";
+    static REPOSITORY_QUALIFIER = "repository_url";
+    static TAG_QUALIFIER = "tag";
+    static ARCH_QUALIFIER = "arch";
+    static OS_QUALIFIER = "os";
+    static VARIANT_QUALIFIER = "variant";
+    /** @type {Image} */
+    image;
+    /** @type {Platform} */
+    platform;
+    /**
+     * @param {string} image
+     * @param {string} [platform]
+     * @param {import("index.js").Options} [opts={}]
+     */
+    constructor(image, platform, opts) {
+        this.image = new Image(image);
+        if (platform != null) {
+            this.platform = Platform.fromString(platform);
+        }
+        this.checkImageDigest(opts);
+    }
+    /**
+     * @private
+     */
+    checkImageDigest(opts) {
+        if (this.image.digest == null) {
+            try {
+                const digests = getImageDigests(this, opts);
+                if (digests.size === 0) {
+                    throw new Error("Failed to get any image digest");
+                }
+                if (digests.size === 1 && digests[Platform.EMPTY.toString()]) {
+                    this.image.digest = digests[Platform.EMPTY.toString()];
+                }
+                else {
+                    if (this.platform == null) {
+                        this.platform = getImagePlatform(opts);
+                    }
+                    if (this.platform == null) {
+                        throw new Error(`Failed to get image platform for image digest`);
+                    }
+                    if (!digests[this.platform.toString()]) {
+                        throw new Error(`Failed to get image digest for platform ${this.platform}`);
+                    }
+                    this.image.digest = digests[this.platform.toString()];
+                }
+            }
+            catch (ex) {
+                throw new Error("Failed to get image digest", { cause: ex });
+            }
+        }
+    }
+    /**
+     * @returns {PackageURL}
+     * @throws {Error}
+     * @see https://github.com/package-url/purl-spec/blob/master/PURL-TYPES.rst#oci
+     */
+    getPackageURL() {
+        /** @type {Object.<string, string>} */
+        const qualifiers = {};
+        const repositoryUrl = this.image.getNameWithoutTag();
+        const simpleName = this.image.getSimpleName();
+        if (repositoryUrl != null && repositoryUrl.toLowerCase() !== simpleName.toLowerCase()) {
+            qualifiers[ImageRef.REPOSITORY_QUALIFIER] = repositoryUrl.toLowerCase();
+        }
+        if (this.platform != null) {
+            qualifiers[ImageRef.ARCH_QUALIFIER] = this.platform.architecture.toLowerCase();
+            qualifiers[ImageRef.OS_QUALIFIER] = this.platform.os.toLowerCase();
+            if (this.platform.variant != null) {
+                qualifiers[ImageRef.VARIANT_QUALIFIER] = this.platform.variant.toLowerCase();
+            }
+        }
+        const tag = this.image.tag;
+        if (tag != null) {
+            qualifiers[ImageRef.TAG_QUALIFIER] = tag;
+        }
+        return new PackageURL(ImageRef.OCI_TYPE, null, this.image.getSimpleName().toLowerCase(), this.image.digest.toLowerCase(), qualifiers, null);
+    }
+}

package/dist/src/oci_image/platform.d.ts

@@ -0,0 +1,59 @@
+/**
+* Class representing a Platform with OS, architecture, and variant information
+*/
+export class Platform {
+    static EMPTY: Platform;
+    static SUPPORTED_PLATFORMS: Platform[];
+    /**
+     * Get the variant for the given OS and architecture
+     * @param {string} os - Operating system
+     * @param {string} arch - Architecture
+     * @returns {string|null} - Variant or null
+     */
+    static getVariant(os: string, arch: string): string | null;
+    /**
+     * Check if a variant is required for the given OS and architecture
+     * @param {string} os - Operating system
+     * @param {string} arch - Architecture
+     * @returns {boolean} - True if variant is required
+     */
+    static isVariantRequired(os: string, arch: string): boolean;
+    /**
+     * Create a platform from a string
+     * @param {string} platform - Platform string in format "os/arch" or "os/arch/variant"
+     * @returns {Platform} - Platform instance
+     * @throws {Error} - If platform string is invalid or not supported
+     */
+    static fromString(platform: string): Platform;
+    /**
+     * Create a platform from individual components
+     * @param {string|null} os - Operating system
+     * @param {string} arch - Architecture
+     * @param {string|null} variant - Architecture variant
+     * @returns {Platform} - Platform instance
+     * @throws {Error} - If platform is invalid or not supported
+     */
+    static fromComponents(os: string | null, arch: string, variant: string | null): Platform;
+    /**
+     * Check if a platform is supported
+     * @param {Platform} platform - Platform to check
+     * @returns {boolean} - True if platform is supported
+     */
+    static isSupported(platform: Platform): boolean;
+    /**
+     * Create a Platform instance
+     * @param {string|null} os - Operating system
+     * @param {string|null} architecture - Architecture
+     * @param {string|null} [variant] - Architecture variant
+     * @private
+     */
+    private constructor();
+    os: string | null;
+    architecture: string | null;
+    variant: string | null | undefined;
+    /**
+     * Convert a platform to a string
+     * @returns {string} - String representation of platform
+     */
+    toString(): string;
+}

package/dist/src/oci_image/platform.js

@@ -0,0 +1,138 @@
+/**
+* Class representing a Platform with OS, architecture, and variant information
+*/
+export class Platform {
+    static EMPTY = new Platform(null, null, null);
+    // $GOOS and $GOARCH
+    // https://github.com/docker-library/bashbrew/blob/v0.1.2/architecture/oci-platform.go#L14-L27
+    static SUPPORTED_PLATFORMS = [
+        new Platform('linux', 'amd64', null),
+        new Platform('linux', 'arm', 'v5'),
+        new Platform('linux', 'arm', 'v6'),
+        new Platform('linux', 'arm', 'v7'),
+        new Platform('linux', 'arm64', 'v8'),
+        new Platform('linux', '386', null),
+        new Platform('linux', 'mips64le', null),
+        new Platform('linux', 'ppc64le', null),
+        new Platform('linux', 'riscv64', null),
+        new Platform('linux', 's390x', null),
+        new Platform('windows', 'arm64', null)
+    ];
+    /**
+     * Create a Platform instance
+     * @param {string|null} os - Operating system
+     * @param {string|null} architecture - Architecture
+     * @param {string|null} [variant] - Architecture variant
+     * @private
+     */
+    constructor(os, architecture, variant) {
+        this.os = os;
+        this.architecture = architecture;
+        this.variant = variant;
+    }
+    /**
+     * Get the variant for the given OS and architecture
+     * @param {string} os - Operating system
+     * @param {string} arch - Architecture
+     * @returns {string|null} - Variant or null
+     */
+    static getVariant(os, arch) {
+        if (os === 'linux' && arch === 'arm64') { // in case variant "v8" is not specified
+            return 'v8';
+        }
+        return null;
+    }
+    /**
+     * Check if a variant is required for the given OS and architecture
+     * @param {string} os - Operating system
+     * @param {string} arch - Architecture
+     * @returns {boolean} - True if variant is required
+     */
+    static isVariantRequired(os, arch) {
+        return os === 'linux' && arch === 'arm';
+    }
+    /**
+     * Create a platform from a string
+     * @param {string} platform - Platform string in format "os/arch" or "os/arch/variant"
+     * @returns {Platform} - Platform instance
+     * @throws {Error} - If platform string is invalid or not supported
+     */
+    static fromString(platform) {
+        if (platform == null) {
+            throw new Error(`Invalid platform: ${platform}`);
+        }
+        const parts = platform.split('/');
+        let os, arch, variant;
+        if (parts.length === 1) {
+            os = 'linux';
+            arch = parts[0];
+        }
+        else if (parts.length === 2) {
+            os = parts[0];
+            arch = parts[1];
+            variant = Platform.getVariant(os, arch);
+        }
+        else if (parts.length === 3) {
+            os = parts[0];
+            arch = parts[1];
+            variant = parts[2];
+        }
+        else {
+            throw new Error(`Invalid platform: ${platform}`);
+        }
+        const platformObj = new Platform(os, arch, variant);
+        if (!Platform.isSupported(platformObj)) {
+            throw new Error(`Image platform is not supported: ${platformObj.toString()}`);
+        }
+        return platformObj;
+    }
+    /**
+     * Create a platform from individual components
+     * @param {string|null} os - Operating system
+     * @param {string} arch - Architecture
+     * @param {string|null} variant - Architecture variant
+     * @returns {Platform} - Platform instance
+     * @throws {Error} - If platform is invalid or not supported
+     */
+    static fromComponents(os, arch, variant) {
+        if (arch == null) {
+            throw new Error(`Invalid platform arch: ${arch}`);
+        }
+        // Default to linux if OS is not specified
+        if (os == null) {
+            os = 'linux';
+        }
+        // Get default variant if not specified
+        if (variant == null) {
+            variant = Platform.getVariant(os, arch);
+        }
+        const platformObj = new Platform(os, arch, variant);
+        if (!Platform.isSupported(platformObj)) {
+            throw new Error(`Image platform is not supported: ${os}/${arch}/${variant}`);
+        }
+        return platformObj;
+    }
+    /**
+     * Check if a platform is supported
+     * @param {Platform} platform - Platform to check
+     * @returns {boolean} - True if platform is supported
+     */
+    static isSupported(platform) {
+        return Platform.SUPPORTED_PLATFORMS.some(p => p.os === platform.os &&
+            p.architecture === platform.architecture &&
+            // eslint-disable-next-line eqeqeq
+            p.variant == platform.variant);
+    }
+    /**
+     * Convert a platform to a string
+     * @returns {string} - String representation of platform
+     */
+    toString() {
+        if (this.variant == null) {
+            return `${this.os}/${this.architecture}`;
+        }
+        else {
+            return `${this.os}/${this.architecture}/${this.variant}`;
+        }
+    }
+}

package/dist/src/oci_image/utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ *
+ * @param {import('./images').ImageRef} imageRef
+ * @param {import("../index.js").Options} [opts={}] - optional various options to pass along the application
+ * @returns {{}}
+ */
+export function generateImageSBOM(imageRef: import('./images').ImageRef, opts?: import("../index.js").Options | undefined): {};
+/**
+ *
+ * @param {string} image
+ * @param {import("../index.js").Options} [opts={}] - optional various options to pass along the application
+ * @returns {ImageRef}
+ */
+export function parseImageRef(image: string, opts?: import("../index.js").Options | undefined): ImageRef;
+/**
+ * Gets the platform information for an image
+ * @param {import("../index.js").Options} [opts={}] - optional various options to pass along the application
+ * @returns {Platform|null} - The platform information or null
+ */
+export function getImagePlatform(opts?: import("../index.js").Options | undefined): Platform | null;
+/**
+ * Gets the digests for an image
+ * @param {import('./images').ImageRef} imageRef - The image reference
+ * @param {import("../index.js").Options} [opts={}] - optional various options to pass along the application
+ * @returns {Object.<string, string>} - The image digests
+ * @throws {Error} If the image info is invalid
+ */
+export function getImageDigests(imageRef: import('./images').ImageRef, opts?: import("../index.js").Options | undefined): {
+    [x: string]: string;
+};
+export type SyftImageSource = {
+    getOs: () => string;
+    getArch: () => string;
+    getVariant: () => string;
+};
+export type SyftImageSourceType = {
+    getOs: (arg0: any) => string;
+    getArch: (arg0: any) => string;
+    getVariant: (arg0: any) => string;
+};
+import { ImageRef } from './images.js';
+import { Platform } from './platform.js';