@push.rocks/smartlinuxrepo 1.1.2 → 1.2.0

package/dist_ts/rpm/repodatareader.js

@@ -0,0 +1,414 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { resolveLinuxPackageLimits } from '../shared/limits.js';
+import { assertLinuxCompression, assertReaderBytes, assertReaderInput, readIndexDocument } from '../readers/document.js';
+import { scanXmlDocument } from './xmlreader.js';
+const DOCUMENTS = new Map([
+    ['primary', 'metadata'],
+    ['filelists', 'filelists'],
+    ['other', 'otherdata'],
+]);
+/**
+ * Reads a `primary`, `filelists` or `other` document (`.xml`, `.xml.gz`,
+ * `.xml.xz`, `.xml.zst`; the caller names `compression` and `document`) into
+ * its frame and `<package>` units. The XML rules are the strict scanner's
+ * (see `IRpmXmlFrame`; any refusal is `malformed-index`): the root must be
+ * `<metadata>`, `<filelists>` or `<otherdata>` for the document, and its
+ * children `<package>` elements with only whitespace between them, which is
+ * not returned. A package without its key (primary `<checksum pkgid="YES">`,
+ * filelists and other `pkgid`) is `missing-field` (`pkgid`); a package with
+ * two of an element the view reads (`<name>`, `<arch>`, `<version>`, `<size>`,
+ * a key `<checksum>`) is `malformed-index`.
+ *
+ * Bounds: the decoded document by `maxIndexBytes`, packages and files per
+ * package by `maxEntries`, one package by `maxMetadataBytes`, one start tag
+ * by `maxHeaderBytes`. Duplicates are kept; all bytes are views into `decoded`.
+ */
+export async function readRpmRepodata(inputArg) {
+    assertReaderInput(inputArg);
+    assertReaderBytes(inputArg.bytes);
+    assertLinuxCompression(inputArg.compression);
+    const document = inputArg.document;
+    const rootName = typeof document === 'string' ? DOCUMENTS.get(document) : undefined;
+    if (rootName === undefined) {
+        throw new LinuxRepoError('invalid-input', "document must be 'primary', 'filelists' or 'other'", {
+            field: 'document',
+            value: typeof document === 'string' ? document : typeof document,
+        });
+    }
+    const limits = resolveLinuxPackageLimits(inputArg.limits);
+    const decoded = await readIndexDocument(inputArg.bytes, inputArg.compression, limits);
+    const packages = [];
+    const frame = scanXmlDocument(decoded, {
+        rootName,
+        unitName: 'package',
+        keepOtherChildren: false,
+        limits,
+        createUnit: (startArg) => new PackageHandler(document, startArg, limits),
+        unit: (handlerArg, startArg, endArg) => {
+            packages.push(handlerArg.result(decoded.subarray(startArg, endArg)));
+        },
+        other: () => undefined,
+    });
+    return { ...frameOf(decoded, rootName, frame), decoded, document, packages };
+}
+/**
+ * Reads an `updateinfo` document into its frame and `<update>` units: the
+ * root must be `<updates>`, the unit key is the `<id>` text (none is
+ * `missing-field`, two are `malformed-index`), and the packages are the
+ * `<pkglist><collection short><package …><filename>` entries in order (a
+ * package with two `<filename>` elements is `malformed-index`). XML rules,
+ * bounds and ownership as `readRpmRepodata`; packages per update count against
+ * `maxEntries`.
+ */
+export async function readRpmUpdateInfo(inputArg) {
+    assertReaderInput(inputArg);
+    assertReaderBytes(inputArg.bytes);
+    assertLinuxCompression(inputArg.compression);
+    const limits = resolveLinuxPackageLimits(inputArg.limits);
+    const decoded = await readIndexDocument(inputArg.bytes, inputArg.compression, limits);
+    const updates = [];
+    const frame = scanXmlDocument(decoded, {
+        rootName: 'updates',
+        unitName: 'update',
+        keepOtherChildren: false,
+        limits,
+        createUnit: (startArg) => new UpdateHandler(startArg, limits),
+        unit: (handlerArg, startArg, endArg) => {
+            updates.push(handlerArg.result(decoded.subarray(startArg, endArg)));
+        },
+        other: () => undefined,
+    });
+    return { ...frameOf(decoded, 'updates', frame), decoded, updates };
+}
+/**
+ * Reads a plain `repomd.xml` into its frame, `<data>` units and the other
+ * root children (kept raw, in `otherElements`). A `<data>` without a `type`
+ * attribute, `<checksum>` or `<location href>` is `missing-field`; a `<data>`
+ * with two of `<checksum>`, `<open-checksum>`, `<location>`, `<timestamp>`,
+ * `<size>` or `<open-size>` is `malformed-index`. XML rules and bounds as
+ * `readRpmRepodata` (the plain input counts against `maxIndexBytes`); all
+ * bytes are views into a copy of the input.
+ */
+export async function readRpmRepomd(inputArg) {
+    assertReaderInput(inputArg);
+    assertReaderBytes(inputArg.bytes);
+    const limits = resolveLinuxPackageLimits(inputArg.limits);
+    const decoded = await readIndexDocument(inputArg.bytes, 'none', limits);
+    const data = [];
+    const otherElements = [];
+    const frame = scanXmlDocument(decoded, {
+        rootName: 'repomd',
+        unitName: 'data',
+        keepOtherChildren: true,
+        limits,
+        createUnit: (startArg) => new RepomdDataHandler(startArg),
+        unit: (handlerArg, startArg, endArg) => {
+            data.push(handlerArg.result(decoded.subarray(startArg, endArg)));
+        },
+        other: (nameArg, startArg, endArg) => {
+            otherElements.push({ name: nameArg, bytes: decoded.subarray(startArg, endArg), offset: startArg });
+        },
+    });
+    return { ...frameOf(decoded, 'repomd', frame), data, otherElements };
+}
+function frameOf(decodedArg, rootNameArg, frameArg) {
+    return {
+        prolog: decodedArg.subarray(0, frameArg.rootStart),
+        rootName: rootNameArg,
+        rootStartTag: decodedArg.subarray(frameArg.rootStart, frameArg.rootStartEnd),
+        rootAttributes: frameArg.rootAttributes.map((attribute) => ({ name: attribute.name, value: attribute.value })),
+        namespace: attributeOf(frameArg.rootAttributes, 'xmlns'),
+        rootEndTag: decodedArg.subarray(frameArg.rootEndStart, frameArg.rootEnd),
+        trailer: decodedArg.subarray(frameArg.rootEnd),
+    };
+}
+function attributeOf(attributesArg, nameArg) {
+    return attributesArg.find((attribute) => attribute.name === nameArg)?.value ?? '';
+}
+function hasAttribute(attributesArg, nameArg) {
+    return attributesArg.some((attribute) => attribute.name === nameArg);
+}
+/** The path of open element names inside one unit, for the handlers' context. */
+class UnitHandler {
+    offset;
+    path = [];
+    constructor(offset) {
+        this.offset = offset;
+    }
+    start(depthArg, nameArg, attributesArg) {
+        const capture = this.open(depthArg, nameArg, attributesArg);
+        this.path.push(nameArg);
+        return capture;
+    }
+    end(depthArg, nameArg, textArg) {
+        this.path.pop();
+        this.close(depthArg, nameArg, textArg);
+    }
+    /** The parent element's name at `depthArg` (the unit element at depth 1). */
+    parent() {
+        return this.path[this.path.length - 1];
+    }
+    duplicate(whatArg) {
+        return new LinuxRepoError('malformed-index', `a unit holds two ${whatArg} elements`, { field: whatArg, value: this.offset });
+    }
+}
+class PackageHandler extends UnitHandler {
+    document;
+    limits;
+    pkgid = null;
+    name = null;
+    arch = null;
+    version = null;
+    size = null;
+    files = [];
+    fileType = '';
+    constructor(document, offsetArg, limits) {
+        super(offsetArg);
+        this.document = document;
+        this.limits = limits;
+    }
+    open(depthArg, nameArg, attributesArg) {
+        if (depthArg === 0) {
+            if (this.document !== 'primary') {
+                if (!hasAttribute(attributesArg, 'pkgid')) {
+                    throw this.missingKey();
+                }
+                this.pkgid = attributeOf(attributesArg, 'pkgid');
+                this.name = attributeOf(attributesArg, 'name');
+                this.arch = attributeOf(attributesArg, 'arch');
+            }
+            return false;
+        }
+        const parent = this.parent();
+        if (depthArg === 1) {
+            if (nameArg === 'version') {
+                if (this.version !== null) {
+                    throw this.duplicate('<version>');
+                }
+                this.version = {
+                    epoch: attributeOf(attributesArg, 'epoch'),
+                    version: attributeOf(attributesArg, 'ver'),
+                    release: attributeOf(attributesArg, 'rel'),
+                };
+                return false;
+            }
+            if (this.document === 'primary') {
+                if (nameArg === 'name' || nameArg === 'arch') {
+                    return true;
+                }
+                if (nameArg === 'checksum') {
+                    return attributeOf(attributesArg, 'pkgid') === 'YES';
+                }
+                if (nameArg === 'size') {
+                    if (this.size !== null) {
+                        throw this.duplicate('<size>');
+                    }
+                    this.size = {
+                        package: attributeOf(attributesArg, 'package'),
+                        installed: attributeOf(attributesArg, 'installed'),
+                        archive: attributeOf(attributesArg, 'archive'),
+                    };
+                    return false;
+                }
+                return false;
+            }
+            if (this.document === 'filelists' && nameArg === 'file') {
+                return this.openFile(attributesArg);
+            }
+            return false;
+        }
+        if (depthArg === 2 && this.document === 'primary' && parent === 'format' && nameArg === 'file') {
+            return this.openFile(attributesArg);
+        }
+        return false;
+    }
+    close(depthArg, nameArg, textArg) {
+        if (textArg === null) {
+            return;
+        }
+        if (nameArg === 'file') {
+            this.files.push({ path: textArg, type: this.fileType });
+        }
+        else if (nameArg === 'name') {
+            if (this.name !== null) {
+                throw this.duplicate('<name>');
+            }
+            this.name = textArg;
+        }
+        else if (nameArg === 'arch') {
+            if (this.arch !== null) {
+                throw this.duplicate('<arch>');
+            }
+            this.arch = textArg;
+        }
+        else if (nameArg === 'checksum') {
+            if (this.pkgid !== null) {
+                throw this.duplicate('<checksum pkgid="YES">');
+            }
+            this.pkgid = textArg;
+        }
+    }
+    openFile(attributesArg) {
+        if (this.files.length + 1 > this.limits.maxEntries) {
+            throw limitExceeded('maxEntries', this.limits.maxEntries, 'files per package');
+        }
+        this.fileType = attributeOf(attributesArg, 'type');
+        return true;
+    }
+    missingKey() {
+        return new LinuxRepoError('missing-field', `a ${this.document} <package> has no pkgid`, { field: 'pkgid', value: this.offset });
+    }
+    result(bytesArg) {
+        if (this.pkgid === null) {
+            throw this.missingKey();
+        }
+        return {
+            bytes: bytesArg,
+            offset: this.offset,
+            pkgid: this.pkgid,
+            name: this.name ?? '',
+            arch: this.arch ?? '',
+            epoch: this.version?.epoch ?? '',
+            version: this.version?.version ?? '',
+            release: this.version?.release ?? '',
+            size: this.size,
+            files: this.files,
+        };
+    }
+}
+class UpdateHandler extends UnitHandler {
+    limits;
+    id = null;
+    collection = '';
+    pending = null;
+    packages = [];
+    constructor(offsetArg, limits) {
+        super(offsetArg);
+        this.limits = limits;
+    }
+    open(depthArg, nameArg, attributesArg) {
+        const parent = this.parent();
+        if (depthArg === 1 && nameArg === 'id') {
+            return true;
+        }
+        if (depthArg === 2 && parent === 'pkglist' && nameArg === 'collection') {
+            this.collection = attributeOf(attributesArg, 'short');
+            return false;
+        }
+        if (depthArg === 3 && parent === 'collection' && this.path[1] === 'pkglist' && nameArg === 'package') {
+            if (this.packages.length + 1 > this.limits.maxEntries) {
+                throw limitExceeded('maxEntries', this.limits.maxEntries, 'packages per update');
+            }
+            this.pending = { attributes: attributesArg, fileName: null };
+            return false;
+        }
+        if (depthArg === 4 && parent === 'package' && this.pending !== null && nameArg === 'filename') {
+            return true;
+        }
+        return false;
+    }
+    close(depthArg, nameArg, textArg) {
+        if (depthArg === 1 && nameArg === 'id' && textArg !== null) {
+            if (this.id !== null) {
+                throw this.duplicate('<id>');
+            }
+            this.id = textArg;
+        }
+        else if (depthArg === 4 && nameArg === 'filename' && textArg !== null && this.pending !== null) {
+            if (this.pending.fileName !== null) {
+                throw this.duplicate('<filename>');
+            }
+            this.pending.fileName = textArg;
+        }
+        else if (depthArg === 3 && nameArg === 'package' && this.pending !== null) {
+            const attributes = this.pending.attributes;
+            this.packages.push({
+                collection: this.collection,
+                name: attributeOf(attributes, 'name'),
+                epoch: attributeOf(attributes, 'epoch'),
+                version: attributeOf(attributes, 'version'),
+                release: attributeOf(attributes, 'release'),
+                arch: attributeOf(attributes, 'arch'),
+                src: attributeOf(attributes, 'src'),
+                fileName: this.pending.fileName ?? '',
+            });
+            this.pending = null;
+        }
+        else if (depthArg === 2 && nameArg === 'collection') {
+            this.collection = '';
+        }
+    }
+    result(bytesArg) {
+        if (this.id === null) {
+            throw new LinuxRepoError('missing-field', 'an <update> has no <id>', { field: 'id', value: this.offset });
+        }
+        return { bytes: bytesArg, offset: this.offset, id: this.id, packages: this.packages };
+    }
+}
+class RepomdDataHandler extends UnitHandler {
+    type = null;
+    values = new Map();
+    pendingType = '';
+    open(depthArg, nameArg, attributesArg) {
+        if (depthArg === 0) {
+            if (hasAttribute(attributesArg, 'type')) {
+                this.type = attributeOf(attributesArg, 'type');
+            }
+            return false;
+        }
+        if (depthArg !== 1) {
+            return false;
+        }
+        switch (nameArg) {
+            case 'checksum':
+            case 'open-checksum':
+            case 'timestamp':
+            case 'size':
+            case 'open-size':
+            case 'location':
+                if (this.values.has(nameArg)) {
+                    throw this.duplicate(`<${nameArg}>`);
+                }
+                if (nameArg === 'location') {
+                    this.values.set(nameArg, { type: '', text: hasAttribute(attributesArg, 'href') ? attributeOf(attributesArg, 'href') : null });
+                    return false;
+                }
+                this.pendingType = attributeOf(attributesArg, 'type');
+                return true;
+            default:
+                return false;
+        }
+    }
+    close(depthArg, nameArg, textArg) {
+        if (depthArg === 1 && textArg !== null) {
+            this.values.set(nameArg, { type: this.pendingType, text: textArg });
+        }
+    }
+    result(bytesArg) {
+        const missing = (fieldArg) => new LinuxRepoError('missing-field', `a repomd <data> has no ${fieldArg}`, { field: fieldArg, value: this.offset });
+        if (this.type === null) {
+            throw missing('type');
+        }
+        const checksum = this.values.get('checksum');
+        if (checksum === undefined || checksum.text === null) {
+            throw missing('checksum');
+        }
+        const location = this.values.get('location');
+        if (location === undefined || location.text === null) {
+            throw missing('location');
+        }
+        const openChecksum = this.values.get('open-checksum');
+        return {
+            bytes: bytesArg,
+            offset: this.offset,
+            type: this.type,
+            location: location.text,
+            checksum: { type: checksum.type, value: checksum.text },
+            openChecksum: openChecksum === undefined || openChecksum.text === null ? null : { type: openChecksum.type, value: openChecksum.text },
+            timestamp: this.values.get('timestamp')?.text ?? null,
+            size: this.values.get('size')?.text ?? null,
+            openSize: this.values.get('open-size')?.text ?? null,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repodatareader.js","sourceRoot":"","sources":["../../ts/rpm/repodatareader.ts"],"names":[],"mappings":"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"}

package/dist_ts/rpm/xmlreader.d.ts

@@ -0,0 +1,70 @@
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+/**
+ * A strict, iterative XML 1.0 scanner over the bytes of one repodata document,
+ * the reading side of `xml.ts`. It checks well-formedness and hands the
+ * elements of each unit (a child of the root) to a handler, without building a
+ * tree. Every refusal is `malformed-index` with the byte offset in
+ * `detail.value`:
+ * - the document must be strict UTF-8 holding only XML characters; an
+ *   optional UTF-8 byte order mark and XML declaration may lead it, and a
+ *   declared `encoding` other than UTF-8 (ASCII case-insensitive) is refused;
+ * - `<!DOCTYPE` (or any other `<!` declaration) is refused, so there are no
+ *   entity definitions: only `&lt; &gt; &amp; &apos; &quot;` and numeric
+ *   references to XML characters are accepted;
+ * - tags must match, attribute names must be unique within a tag and be
+ *   separated by whitespace, values are quoted and hold no `<`, text holds no
+ *   `]]>`, comments hold no `--`, a processing instruction's target is not
+ *   `xml` (except the declaration at the start), and there is exactly one root;
+ * - comments, processing instructions and whitespace may sit before and after
+ *   the root; inside it only whitespace may sit between units; inside a unit
+ *   CDATA sections, comments, processing instructions and empty-element tags
+ *   are accepted.
+ *
+ * Names are matched literally with their prefixes (no namespace processing);
+ * a name starts with an ASCII letter, `_`, `:` or a non-ASCII character and
+ * continues with those, digits, `.` and `-` (every non-ASCII character counts
+ * as a name character, a simplification of the XML name production). Values
+ * handed to the handler are decoded: references replaced, line ends
+ * normalized (CRLF and CR to LF), and in attribute values literal tabs and
+ * line ends become spaces (XML 1.0 sections 2.11 and 3.3.3).
+ *
+ * Bounds: one start tag by `maxHeaderBytes`, one unit by `maxMetadataBytes`,
+ * units and open elements at a time by `maxEntries`.
+ */
+export interface IXmlAttribute {
+    readonly name: string;
+    readonly value: string;
+}
+/** Receives the elements of one unit; `depth` 0 is the unit element itself. */
+export interface IXmlUnitHandler {
+    /** An element starts; returning true captures its direct character data for `end`. */
+    start(depthArg: number, nameArg: string, attributesArg: readonly IXmlAttribute[]): boolean;
+    /** An element ends; `textArg` is its captured character data, or null when not captured. */
+    end(depthArg: number, nameArg: string, textArg: string | null): void;
+}
+export interface IXmlScanOptions {
+    /** The required root element name. */
+    rootName: string;
+    /** The unit element name among the root's children. */
+    unitName: string;
+    /** Whether other root children are accepted (repomd); otherwise they are refused. */
+    keepOtherChildren: boolean;
+    limits: Readonly<ILinuxPackageLimits>;
+    /** A handler for the unit starting at `startArg` (the offset of its `<`). */
+    createUnit(startArg: number): IXmlUnitHandler;
+    /** A unit ended: its bytes are `[startArg, endArg)`. */
+    unit(handlerArg: IXmlUnitHandler, startArg: number, endArg: number): void;
+    /** Another root child ended (only with `keepOtherChildren`). */
+    other(nameArg: string, startArg: number, endArg: number): void;
+}
+/** Where the root element's tags sit in the document. */
+export interface IXmlFrameScan {
+    rootStart: number;
+    rootStartEnd: number;
+    rootAttributes: IXmlAttribute[];
+    /** The root end tag `[rootEndStart, rootEnd)`; both equal `rootStartEnd` for an empty-element root. */
+    rootEndStart: number;
+    rootEnd: number;
+}
+/** Scans one document; see the module comment. */
+export declare function scanXmlDocument(documentArg: Uint8Array, optionsArg: IXmlScanOptions): IXmlFrameScan;