trm-core 9.10.6 → 10.0.1

package/dist/manifest/engines/validateEngines.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TABLE_VALUE_FORBIDDEN_REGEX = exports.TABLE_VALUE_MAX_LENGTH = exports.ENGINES_TABLE_CONDITION_PROPS = exports.ENGINES_TABLE_PROPS = exports.ENGINES_NOTE_PROPS = exports.ENGINES_PRODUCT_PROPS = exports.ENGINES_COMPONENT_PROPS = exports.FIELD_NAME_REGEX = exports.TABLE_NAME_REGEX = exports.NOTE_REGEX = exports.PRODUCT_NAME_REGEX = exports.COMPONENT_NAME_REGEX = exports.ENGINES_MAX_ANYOF_DEPTH = exports.ENGINES_TABLE_OPERATORS = exports.ENGINES_TRM_PACKAGES = exports.ENGINES_KEYS = void 0;
+exports.normalizeEngineName = normalizeEngineName;
+exports.normalizeNoteNumber = normalizeNoteNumber;
+exports.validTrmRange = validTrmRange;
+exports.validateEngines = validateEngines;
+exports.normalizeEngines = normalizeEngines;
+const sapRange_1 = require("./sapRange");
+const semver_1 = require("semver");
+exports.ENGINES_KEYS = ['trm', 'components', 'products', 'notes', 'tables', 'anyOf'];
+//the only TRM packages an engines declaration can constrain
+exports.ENGINES_TRM_PACKAGES = ['trm-core', 'trm-server'];
+exports.ENGINES_TABLE_OPERATORS = ['EQ', 'NE', 'LT', 'LE', 'GT', 'GE', 'LIKE'];
+exports.ENGINES_MAX_ANYOF_DEPTH = 3;
+exports.COMPONENT_NAME_REGEX = /^[A-Z0-9_\/-]+$/;
+exports.PRODUCT_NAME_REGEX = /^[A-Z0-9_\/\-. ]+$/;
+exports.NOTE_REGEX = /^\d{1,10}$/;
+exports.TABLE_NAME_REGEX = /^[A-Z0-9_\/]{1,30}$/;
+exports.FIELD_NAME_REGEX = /^[A-Z0-9_\/]{1,30}$/;
+//supported properties of each engine check, with the range mode of versioned properties
+exports.ENGINES_COMPONENT_PROPS = { release: 'release', sp: 'number' };
+exports.ENGINES_PRODUCT_PROPS = { version: 'version' };
+exports.ENGINES_NOTE_PROPS = { version: 'number' };
+exports.ENGINES_TABLE_PROPS = ['table', 'where'];
+exports.ENGINES_TABLE_CONDITION_PROPS = ['field', 'op', 'value'];
+//RFC_READ_TABLE option lines are limited to 72 characters (field + operator + quoted value)
+exports.TABLE_VALUE_MAX_LENGTH = 32;
+//read table options are split on AND/OR operators
+exports.TABLE_VALUE_FORBIDDEN_REGEX = /\s(AND|OR)\s/i;
+function isPlainObject(o) {
+    return typeof o === 'object' && o !== null && !Array.isArray(o);
+}
+function normalizeEngineName(name) {
+    return name.trim().toUpperCase().replace(/\s+/g, ' ');
+}
+function normalizeNoteNumber(note) {
+    return parseInt(note.toString().trim(), 10).toString();
+}
+function checkConstraint(errors, path, constraint, props, strict, expected) {
+    if (!isPlainObject(constraint)) {
+        errors.push(`${path}: expected ${expected}.`);
+        return;
+    }
+    Object.keys(constraint).forEach(prop => {
+        const mode = props[prop];
+        if (!mode) {
+            if (strict) {
+                errors.push(`${path}: unknown property "${prop}".`);
+            }
+            return;
+        }
+        if (typeof constraint[prop] !== 'string' || !(0, sapRange_1.validSapRange)(constraint[prop], mode)) {
+            errors.push(`${path}.${prop}: invalid range "${constraint[prop]}".`);
+        }
+    });
+}
+//keys are case and whitespace (names) or leading-zero (notes) insensitive: two keys normalizing to the same value would collapse
+function checkDuplicate(errors, path, seen, key, normalized) {
+    if (seen.has(normalized)) {
+        errors.push(`${path}: "${key}" duplicates "${seen.get(normalized)}".`);
+    }
+    else {
+        seen.set(normalized, key);
+    }
+}
+function checkVersionedMap(errors, path, map, nameRegex, props, allowFalse, strict) {
+    if (!isPlainObject(map)) {
+        errors.push(`${path}: expected an object.`);
+        return;
+    }
+    const seen = new Map();
+    Object.keys(map).forEach(name => {
+        const itemPath = `${path}.${name}`;
+        if (!nameRegex.test(normalizeEngineName(name))) {
+            errors.push(`${itemPath}: invalid name.`);
+        }
+        else {
+            checkDuplicate(errors, path, seen, name, normalizeEngineName(name));
+        }
+        const value = map[name];
+        if (value === true || (value === false && allowFalse)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                errors.push(`${itemPath}: alternatives list is empty.`);
+            }
+            value.forEach((o, i) => checkConstraint(errors, `${itemPath}[${i}]`, o, props, strict, 'an object'));
+        }
+        else {
+            checkConstraint(errors, itemPath, value, props, strict, `${allowFalse ? 'true, false' : 'true'}, an object or an array of objects`);
+        }
+    });
+}
+function checkNotes(errors, path, notes, strict) {
+    if (!isPlainObject(notes)) {
+        errors.push(`${path}: expected an object.`);
+        return;
+    }
+    const seen = new Map();
+    Object.keys(notes).forEach(note => {
+        const itemPath = `${path}.${note}`;
+        if (!exports.NOTE_REGEX.test(note.trim()) || parseInt(note, 10) === 0) {
+            errors.push(`${itemPath}: invalid SAP Note number.`);
+        }
+        else {
+            checkDuplicate(errors, path, seen, note, normalizeNoteNumber(note));
+        }
+        const value = notes[note];
+        if (value === true) {
+            return;
+        }
+        checkConstraint(errors, itemPath, value, exports.ENGINES_NOTE_PROPS, strict, 'true or an object');
+    });
+}
+function validTrmRange(range) {
+    return typeof range === 'string' && range.trim().length > 0 && (0, semver_1.validRange)(range.trim()) !== null;
+}
+function checkTrm(errors, path, trm) {
+    if (!isPlainObject(trm) || Object.keys(trm).length === 0) {
+        errors.push(`${path}: expected an object with at least one of ${exports.ENGINES_TRM_PACKAGES.join(', ')}.`);
+        return;
+    }
+    Object.keys(trm).forEach(name => {
+        //unknown packages are errors even when not strict: these are the only packages that can be constrained
+        if (!exports.ENGINES_TRM_PACKAGES.includes(name)) {
+            errors.push(`${path}.${name}: unknown TRM package, expected one of ${exports.ENGINES_TRM_PACKAGES.join(', ')}.`);
+        }
+        else if (!validTrmRange(trm[name])) {
+            errors.push(`${path}.${name}: invalid range "${trm[name]}".`);
+        }
+    });
+}
+function checkTables(errors, path, tables, strict) {
+    if (!Array.isArray(tables)) {
+        errors.push(`${path}: expected an array.`);
+        return;
+    }
+    tables.forEach((check, i) => {
+        const itemPath = `${path}[${i}]`;
+        if (!isPlainObject(check)) {
+            errors.push(`${itemPath}: expected an object.`);
+            return;
+        }
+        if (strict) {
+            Object.keys(check).filter(k => !exports.ENGINES_TABLE_PROPS.includes(k)).forEach(k => errors.push(`${itemPath}: unknown property "${k}".`));
+        }
+        if (typeof check.table !== 'string' || !exports.TABLE_NAME_REGEX.test(check.table.trim().toUpperCase())) {
+            errors.push(`${itemPath}.table: invalid table name.`);
+        }
+        if (!Array.isArray(check.where) || check.where.length === 0) {
+            errors.push(`${itemPath}.where: expected a non-empty array of conditions.`);
+            return;
+        }
+        check.where.forEach((condition, j) => {
+            const conditionPath = `${itemPath}.where[${j}]`;
+            if (!isPlainObject(condition)) {
+                errors.push(`${conditionPath}: expected an object.`);
+                return;
+            }
+            if (strict) {
+                Object.keys(condition).filter(k => !exports.ENGINES_TABLE_CONDITION_PROPS.includes(k)).forEach(k => errors.push(`${conditionPath}: unknown property "${k}".`));
+            }
+            if (typeof condition.field !== 'string' || !exports.FIELD_NAME_REGEX.test(condition.field.trim().toUpperCase())) {
+                errors.push(`${conditionPath}.field: invalid field name.`);
+            }
+            if (condition.op !== undefined && (typeof condition.op !== 'string' || !exports.ENGINES_TABLE_OPERATORS.includes(condition.op.trim().toUpperCase()))) {
+                errors.push(`${conditionPath}.op: invalid operator "${condition.op}", expected one of ${exports.ENGINES_TABLE_OPERATORS.join(', ')}.`);
+            }
+            if ((typeof condition.value !== 'string' && typeof condition.value !== 'number') || condition.value.toString().length > exports.TABLE_VALUE_MAX_LENGTH) {
+                errors.push(`${conditionPath}.value: expected a string (max ${exports.TABLE_VALUE_MAX_LENGTH} characters).`);
+            }
+            else if (exports.TABLE_VALUE_FORBIDDEN_REGEX.test(condition.value.toString())) {
+                errors.push(`${conditionPath}.value: must not contain " AND " or " OR ".`);
+            }
+        });
+    });
+}
+function checkEngines(errors, path, engines, depth, strict) {
+    if (!isPlainObject(engines)) {
+        errors.push(`${path}: expected an object.`);
+        return;
+    }
+    Object.keys(engines).forEach(key => {
+        const keyPath = `${path}.${key}`;
+        switch (key) {
+            case 'trm':
+                checkTrm(errors, keyPath, engines.trm);
+                break;
+            case 'components':
+                checkVersionedMap(errors, keyPath, engines.components, exports.COMPONENT_NAME_REGEX, exports.ENGINES_COMPONENT_PROPS, true, strict);
+                break;
+            case 'products':
+                checkVersionedMap(errors, keyPath, engines.products, exports.PRODUCT_NAME_REGEX, exports.ENGINES_PRODUCT_PROPS, true, strict);
+                break;
+            case 'notes':
+                checkNotes(errors, keyPath, engines.notes, strict);
+                break;
+            case 'tables':
+                checkTables(errors, keyPath, engines.tables, strict);
+                break;
+            case 'anyOf':
+                if (depth >= exports.ENGINES_MAX_ANYOF_DEPTH) {
+                    errors.push(`${keyPath}: maximum nesting depth (${exports.ENGINES_MAX_ANYOF_DEPTH}) exceeded.`);
+                }
+                else if (!Array.isArray(engines.anyOf) || engines.anyOf.length === 0) {
+                    errors.push(`${keyPath}: expected a non-empty array.`);
+                }
+                else {
+                    engines.anyOf.forEach((o, i) => checkEngines(errors, `${keyPath}[${i}]`, o, depth + 1, strict));
+                }
+                break;
+            default:
+                if (strict) {
+                    errors.push(`${keyPath}: unknown engine check.`);
+                }
+        }
+    });
+}
+/**
+ * Formally validates a manifest engines declaration.
+ * Returns the list of errors (empty when valid).
+ */
+function validateEngines(engines, options) {
+    const errors = [];
+    checkEngines(errors, 'engines', engines, 0, !!(options === null || options === void 0 ? void 0 : options.strict));
+    return errors;
+}
+function normalizeConstraint(constraint) {
+    if (typeof constraint === 'boolean') {
+        return constraint;
+    }
+    if (Array.isArray(constraint)) {
+        return constraint.map(normalizeConstraint);
+    }
+    const normalized = {};
+    Object.keys(constraint).forEach(prop => {
+        normalized[prop] = typeof constraint[prop] === 'string' ? constraint[prop].trim().toUpperCase() : constraint[prop];
+    });
+    return normalized;
+}
+/**
+ * Normalizes a (valid) engines declaration: uppercase names, note numbers without leading zeros,
+ * default table operator `EQ`. Unknown keys are kept untouched.
+ */
+function normalizeEngines(engines) {
+    const normalized = {};
+    Object.keys(engines).forEach(key => {
+        switch (key) {
+            case 'trm':
+                normalized.trm = {};
+                Object.keys(engines.trm).forEach(name => {
+                    normalized.trm[name] = engines.trm[name].trim();
+                });
+                break;
+            case 'components':
+            case 'products':
+                normalized[key] = {};
+                Object.keys(engines[key]).forEach(name => {
+                    normalized[key][normalizeEngineName(name)] = normalizeConstraint(engines[key][name]);
+                });
+                break;
+            case 'notes':
+                normalized.notes = {};
+                Object.keys(engines.notes).forEach(note => {
+                    normalized.notes[normalizeNoteNumber(note)] = normalizeConstraint(engines.notes[note]);
+                });
+                break;
+            case 'tables':
+                //unknown properties are kept so the engines check can report them as unsupported
+                normalized.tables = engines.tables.map(check => (Object.assign(Object.assign({}, check), { table: check.table.trim().toUpperCase(), where: check.where.map(condition => (Object.assign(Object.assign({}, condition), { field: condition.field.trim().toUpperCase(), op: (condition.op || 'EQ').trim().toUpperCase(), value: condition.value.toString() }))) })));
+                break;
+            case 'anyOf':
+                normalized.anyOf = engines.anyOf.map(normalizeEngines);
+                break;
+            default:
+                normalized[key] = engines[key];
+        }
+    });
+    return normalized;
+}

package/dist/manifest/index.d.ts

@@ -6,3 +6,6 @@ export * from "./TrmManifestDependency";
 export * from "./TrmManifestNamespace";
 export * from "./TrmManifestPostActivity";
 export * from "./PostActivity";
+export * from "./TrmManifestEngines";
+export * from "./engines";
+export * from "./sapEntries";

package/dist/manifest/index.js

@@ -22,3 +22,6 @@ __exportStar(require("./TrmManifestDependency"), exports);
 __exportStar(require("./TrmManifestNamespace"), exports);
 __exportStar(require("./TrmManifestPostActivity"), exports);
 __exportStar(require("./PostActivity"), exports);
+__exportStar(require("./TrmManifestEngines"), exports);
+__exportStar(require("./engines"), exports);
+__exportStar(require("./sapEntries"), exports);

package/dist/manifest/sapEntries.d.ts

@@ -0,0 +1,14 @@
+export declare const SAP_ENTRY_CONDITION_MAX_LENGTH = 72;
+/**
+ * Builds the read-table conditions (`FIELD EQ 'value'`) identifying a required SAP entry.
+ *
+ * @throws When the entry is empty, a field name is invalid, a value is not a string or number,
+ * contains " AND " or " OR ", or its condition exceeds one option line.
+ */
+export declare function getSapEntryConditions(sapEntry: any): string[];
+/**
+ * Validates a manifest `sapEntries` map.
+ *
+ * @returns One message per invalid table name or entry; empty when the declaration is valid.
+ */
+export declare function validateSapEntries(sapEntries: any): string[];

package/dist/manifest/sapEntries.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAP_ENTRY_CONDITION_MAX_LENGTH = void 0;
+exports.getSapEntryConditions = getSapEntryConditions;
+exports.validateSapEntries = validateSapEntries;
+const engines_1 = require("./engines");
+//RFC_READ_TABLE option lines are limited to 72 characters, and a single condition cannot be split
+exports.SAP_ENTRY_CONDITION_MAX_LENGTH = 72;
+/**
+ * Builds the read-table conditions (`FIELD EQ 'value'`) identifying a required SAP entry.
+ *
+ * @throws When the entry is empty, a field name is invalid, a value is not a string or number,
+ * contains " AND " or " OR ", or its condition exceeds one option line.
+ */
+function getSapEntryConditions(sapEntry) {
+    if (typeof sapEntry !== 'object' || sapEntry === null || Array.isArray(sapEntry) || Object.keys(sapEntry).length === 0) {
+        throw new Error(`SAP entry must be an object with at least one field.`);
+    }
+    return Object.keys(sapEntry).map(key => {
+        const field = key.trim().toUpperCase();
+        if (!engines_1.FIELD_NAME_REGEX.test(field)) {
+            throw new Error(`SAP entry field "${key}" is not a valid field name.`);
+        }
+        const value = sapEntry[key];
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new Error(`SAP entry field "${key}" must have a string or number value.`);
+        }
+        if (engines_1.TABLE_VALUE_FORBIDDEN_REGEX.test(value.toString())) {
+            throw new Error(`SAP entry field "${key}" value must not contain " AND " or " OR ".`);
+        }
+        const condition = `${field} EQ '${value.toString().replace(/'/g, "''")}'`;
+        if (condition.length > exports.SAP_ENTRY_CONDITION_MAX_LENGTH) {
+            throw new Error(`SAP entry field "${key}" value is too long (condition exceeds ${exports.SAP_ENTRY_CONDITION_MAX_LENGTH} characters).`);
+        }
+        return condition;
+    });
+}
+/**
+ * Validates a manifest `sapEntries` map.
+ *
+ * @returns One message per invalid table name or entry; empty when the declaration is valid.
+ */
+function validateSapEntries(sapEntries) {
+    const errors = [];
+    Object.keys(sapEntries).forEach(table => {
+        if (!engines_1.TABLE_NAME_REGEX.test(table.trim().toUpperCase())) {
+            errors.push(`sapEntries.${table}: invalid table name.`);
+        }
+        if (!Array.isArray(sapEntries[table])) {
+            errors.push(`sapEntries.${table}: expected an array.`);
+            return;
+        }
+        sapEntries[table].forEach((entry, i) => {
+            try {
+                getSapEntryConditions(entry);
+            }
+            catch (e) {
+                errors.push(`sapEntries.${table}[${i}]: ${e.message}`);
+            }
+        });
+    });
+    return errors;
+}

package/dist/protocol/Protocol.js

@@ -26,6 +26,13 @@ class Protocol {
                 const nodePath = process.execPath;
                 const address = this._server.address();
                 const url = `http://localhost:${address.port}`;
+                /*await ProtocolRegistry.register({
+                    protocol: "trm",
+                    command: `"${nodePath}" "${path.join(__dirname, "./callback.js")}" ${url} $_URL_`,
+                    override: true,
+                    terminal: false,
+                    script: false
+                });*/
                 yield protocol_registry_1.default.register(`trm`, `"${nodePath}" "${path_1.default.join(__dirname, "./callback.js")}" ${url} $_URL_`, {
                     override: true,
                     terminal: true

package/dist/registry/AbstractRegistry.d.ts

@@ -1,6 +1,19 @@
-import { BatchCompareRequest, BatchCompareResponse, Deprecate, DistTagAdd, DistTagRm, Package, PackageContents, Ping, WhoAmI } from "trm-registry-types";
+import { BatchCompareRequest, BatchCompareResponse, Deprecate, DistTagAdd, DistTagRm, Package, Ping, WhoAmI } from "trm-registry-types";
 import { RegistryType } from "./RegistryType";
 import { TrmArtifact } from "../trmPackage";
+import { BinaryTransport } from "../transport";
+import { TransportEntries } from "../client";
+export interface PublishAdditionalData {
+    readme?: string;
+    tags?: string;
+    changelog?: string;
+    retainedCustomizing?: string[];
+}
+/** Release data returned by a registry after publication. */
+export interface PublishResult {
+    /** Integrity of the release as stored by the registry, when it can differ from the uploaded artifact. */
+    integrity?: string;
+}
 export declare abstract class AbstractRegistry {
     endpoint: string;
     name: string;
@@ -13,11 +26,13 @@ export declare abstract class AbstractRegistry {
     abstract getPackage: (fullName: string, version: string) => Promise<Package>;
     abstract downloadArtifact: (fullName: string, version: string) => Promise<TrmArtifact>;
     abstract validatePublish: (fullName: string, version: string, isPrivate: boolean) => Promise<void>;
-    abstract publish: (fullName: string, version: string, artifact: TrmArtifact, readme?: string, tags?: string, changelog?: string) => Promise<Package | void>;
+    abstract publish: (fullName: string, version: string, artifact: TrmArtifact, additionalData?: PublishAdditionalData) => Promise<PublishResult | void>;
     abstract unpublish: (fullName: string, version: string) => Promise<void>;
     abstract deprecate: (fullName: string, version: string, deprecate: Deprecate) => Promise<void>;
     abstract addDistTag: (fullName: string, distTag: DistTagAdd) => Promise<void>;
     abstract rmDistTag: (fullName: string, distTag: DistTagRm) => Promise<void>;
     abstract batchCompare: (packages: BatchCompareRequest) => Promise<BatchCompareResponse>;
-    abstract contents: (fullName: string, version: string) => Promise<PackageContents>;
+    abstract transport: (trkorr: string, target?: string) => Promise<BinaryTransport>;
+    abstract transportEntries: (fullName: string, version: string, trkorr: string) => Promise<TransportEntries>;
+    abstract delete: (transport: BinaryTransport) => Promise<BinaryTransport>;
 }

package/dist/registry/FileSystem.d.ts

@@ -1,7 +1,9 @@
-import { BatchCompareRequest, BatchCompareResponse, Deprecate, DistTagAdd, DistTagRm, Package, PackageContents, Ping, WhoAmI } from "trm-registry-types";
+import { BatchCompareResponse, Package, Ping, WhoAmI } from "trm-registry-types";
 import { AbstractRegistry } from "./AbstractRegistry";
 import { RegistryType } from "./RegistryType";
-import { TrmArtifact } from "../trmPackage";
+import { TrmArtifact, TrmPackage } from "../trmPackage";
+import { BinaryTransport } from "../transport";
+import { TransportEntries } from "../client";
 export declare const LOCAL_RESERVED_KEYWORD = "local";
 export declare class FileSystem implements AbstractRegistry {
     private _filePath?;
@@ -11,19 +13,26 @@ export declare class FileSystem implements AbstractRegistry {
     constructor(_filePath?: string);
     compare(registry: AbstractRegistry): boolean;
     getRegistryType(): RegistryType;
-    authenticate(defaultData: any): Promise<AbstractRegistry>;
+    authenticate(): Promise<AbstractRegistry>;
     getAuthData(): any;
     ping(): Promise<Ping>;
     whoAmI(): Promise<WhoAmI>;
     getPackage(fullName: string, version: string): Promise<Package>;
-    downloadArtifact(fullName: string, version: string): Promise<TrmArtifact>;
-    getArtifact(name: string, version?: string): Promise<TrmArtifact>;
-    validatePublish(fullName: string, version: string): Promise<void>;
-    publish(fullName: string, version: string, artifact: TrmArtifact, readme?: string): Promise<Package>;
-    unpublish(fullName: string, version: string): Promise<void>;
-    deprecate(fullName: string, version: string, deprecate: Deprecate): Promise<void>;
-    addDistTag(fullName: string, distTag: DistTagAdd): Promise<void>;
-    rmDistTag(fullName: string, distTag: DistTagRm): Promise<void>;
-    batchCompare(packages: BatchCompareRequest): Promise<BatchCompareResponse>;
-    contents(fullName: string, version: string): Promise<PackageContents>;
+    downloadArtifact(): Promise<TrmArtifact>;
+    getArtifact(): Promise<TrmArtifact>;
+    validatePublish(): Promise<void>;
+    publish(fullName: string, version: string, artifact: TrmArtifact): Promise<void>;
+    unpublish(): Promise<void>;
+    deprecate(): Promise<void>;
+    addDistTag(): Promise<void>;
+    rmDistTag(): Promise<void>;
+    batchCompare(): Promise<BatchCompareResponse>;
+    transport(): Promise<BinaryTransport>;
+    transportEntries(_fullName: string, _version: string, trkorr: string): Promise<TransportEntries>;
+    delete(_transport: BinaryTransport): Promise<BinaryTransport>;
+    /**
+     * Returns the package of the local artifact, with the registry it was published to.
+     */
+    getRealPackage(): Promise<TrmPackage>;
+    getRealRegistry(): Promise<AbstractRegistry>;
 }

package/dist/registry/FileSystem.js

@@ -17,6 +17,9 @@ const os_1 = require("os");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const promises_1 = require("fs/promises");
+const crypto_1 = require("crypto");
+const RegistryPackageNotFoundError_1 = require("./RegistryPackageNotFoundError");
+const RegistryDeletionTransportUnavailableError_1 = require("./RegistryDeletionTransportUnavailableError");
 exports.LOCAL_RESERVED_KEYWORD = 'local';
 class FileSystem {
     constructor(_filePath) {
@@ -66,7 +69,7 @@ class FileSystem {
     getRegistryType() {
         return RegistryType_1.RegistryType.LOCAL;
     }
-    authenticate(defaultData) {
+    authenticate() {
         return __awaiter(this, void 0, void 0, function* () {
             return this;
         });
@@ -101,6 +104,13 @@ class FileSystem {
     getPackage(fullName, version) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._filePath) {
+                if (!(0, fs_1.existsSync)(this._filePath)) {
+                    throw new RegistryPackageNotFoundError_1.RegistryPackageNotFoundError(fullName, version, this._filePath, undefined);
+                }
+                const artifact = yield this.getArtifact();
+                const manifest = artifact.getManifest();
+                const transportIndex = artifact.getTransportIndex();
+                const transportBinaries = yield artifact.getTransportBinaries();
                 return {
                     name: fullName,
                     dist_tags: {
@@ -109,21 +119,25 @@ class FileSystem {
                     versions: [],
                     yanked_versions: [],
                     deprecated: false,
-                    manifest: null,
-                    checksum: null,
-                    download_link: this._filePath
+                    manifest: manifest ? manifest.get() : undefined,
+                    checksum: (0, crypto_1.createHash)('sha512').update(artifact.binary).digest('base64'),
+                    download_link: this._filePath,
+                    transports: transportIndex.map(transport => (Object.assign(Object.assign({}, transport), { contents: {
+                            download_link: this._filePath,
+                            checksum: transportBinaries.find(item => item.trkorr === transport.trkorr).entriesChecksum
+                        } })))
                 };
             }
             throw new Error(`File system can't view packages!`);
         });
     }
-    downloadArtifact(fullName, version) {
+    downloadArtifact() {
         return __awaiter(this, void 0, void 0, function* () {
             return new trmPackage_1.TrmArtifact((0, fs_1.readFileSync)(this._filePath));
         });
     }
-    getArtifact(name_1) {
-        return __awaiter(this, arguments, void 0, function* (name, version = 'latest') {
+    getArtifact() {
+        return __awaiter(this, void 0, void 0, function* () {
             if (this._filePath) {
                 try {
                     if (!this._artifact) {
@@ -133,55 +147,92 @@ class FileSystem {
                     return this._artifact;
                 }
                 catch (e) {
-                    throw new Error(`File system couldn't read package`);
+                    throw new Error(`File system couldn't read package. The artifact may be incomplete or legacy; republish it with a current TRM version.`);
                 }
             }
             throw new Error(`Missing file path!`);
         });
     }
-    validatePublish(fullName, version) {
+    validatePublish() {
         return __awaiter(this, void 0, void 0, function* () {
+            //always valid, already checked in contructor
         });
     }
-    publish(fullName, version, artifact, readme) {
+    publish(fullName, version, artifact) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._filePath) {
                 yield (0, promises_1.writeFile)(this._filePath, artifact.binary, {
                     flag: 'w'
                 });
-                return this.getPackage(fullName, version);
+                return;
             }
             throw new Error(`Missing file path!`);
         });
     }
-    unpublish(fullName, version) {
+    unpublish() {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error(`File system can't delete packages!`);
         });
     }
-    deprecate(fullName, version, deprecate) {
+    deprecate() {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error(`File system can't deprecate packages!`);
         });
     }
-    addDistTag(fullName, distTag) {
+    addDistTag() {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error(`File system can't add dist tags!`);
         });
     }
-    rmDistTag(fullName, distTag) {
+    rmDistTag() {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error(`File system can't remove dist tags!`);
         });
     }
-    batchCompare(packages) {
+    batchCompare() {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error(`File system cannot compare package versions in registry!`);
         });
     }
-    contents(fullName, version) {
+    transport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error(`File system can't fetch transports!`);
+        });
+    }
+    transportEntries(_fullName, _version, trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = (yield (yield this.getArtifact()).getTransportBinaries()).find(item => item.trkorr === trkorr);
+            if (!transport) {
+                throw new Error(`Transport ${trkorr} was not found in the local artifact.`);
+            }
+            return transport.entries;
+        });
+    }
+    delete(_transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new RegistryDeletionTransportUnavailableError_1.RegistryDeletionTransportUnavailableError(exports.LOCAL_RESERVED_KEYWORD, `Local packages (.trm files) can't generate deletion transports.`);
+        });
+    }
+    /**
+     * Returns the package of the local artifact, with the registry it was published to.
+     */
+    getRealPackage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._filePath) {
+                try {
+                    const artifact = yield this.getArtifact();
+                    return artifact.getManifest().getPackage();
+                }
+                catch (e) {
+                    throw new Error(`File system couldn't read package`);
+                }
+            }
+            throw new Error(`Missing file path!`);
+        });
+    }
+    getRealRegistry() {
         return __awaiter(this, void 0, void 0, function* () {
-            throw new Error(`File system can't see contents!`);
+            return (yield this.getRealPackage()).registry;
         });
     }
 }

package/dist/registry/RegistryDeletionTransportUnauthorizedError.d.ts

@@ -0,0 +1,4 @@
+import { RegistryDeletionTransportUnavailableError } from "./RegistryDeletionTransportUnavailableError";
+export declare class RegistryDeletionTransportUnauthorizedError extends RegistryDeletionTransportUnavailableError {
+    constructor(registryEndpoint: string, originalError: unknown);
+}

package/dist/registry/RegistryDeletionTransportUnauthorizedError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryDeletionTransportUnauthorizedError = void 0;
+const RegistryDeletionTransportUnavailableError_1 = require("./RegistryDeletionTransportUnavailableError");
+class RegistryDeletionTransportUnauthorizedError extends RegistryDeletionTransportUnavailableError_1.RegistryDeletionTransportUnavailableError {
+    constructor(registryEndpoint, originalError) {
+        super(registryEndpoint, `User is not authorized to generate deletion transports in registry "${registryEndpoint}".`, originalError);
+        this.name = 'RegistryDeletionTransportUnauthorizedError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.RegistryDeletionTransportUnauthorizedError = RegistryDeletionTransportUnauthorizedError;