@neon-rs/manifest 0.0.2 → 0.0.4

package/lib/cache/npm.cjs

@@ -0,0 +1,308 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryManifest = exports.NPMCacheCfg = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const change_cjs_1 = require("../change.cjs");
+const jscodeshift_1 = __importDefault(require("jscodeshift"));
+const platform_cjs_1 = require("../platform.cjs");
+const util_cjs_1 = require("../util.cjs");
+const neon_cjs_1 = require("../neon.cjs");
+const abstract_cjs_1 = require("../abstract.cjs");
+const PLATFORMS_DIR = 'platforms';
+class NPMCacheCfg {
+    constructor(manifest, outDir = PLATFORMS_DIR) {
+        this.type = 'npm';
+        this.manifest = manifest;
+        this.outDir = outDir;
+    }
+    // packageFor(target: RustTarget): string | undefined {
+    //   const cfg = this.manifest.cfg();
+    //   const platforms = this.manifest.allPlatforms();
+    //   for (const key in platforms) {
+    //     const value = platforms[key as NodePlatform];
+    //     if (value === target) {
+    //       return `${cfg.org}/${key}`;
+    //     }
+    //   }
+    //   return undefined;
+    // }
+    manifestFor(node, rust) {
+        const targetInfo = (0, platform_cjs_1.describeTarget)(rust);
+        const org = this.manifest.cfg().org;
+        const name = `${org}/${node}`;
+        const json = {
+            name,
+            description: `Prebuilt binary package for \`${this.manifest.name}\` on \`${targetInfo.node}\`.`,
+            version: this.manifest.version,
+            os: [targetInfo.os],
+            cpu: [targetInfo.arch],
+            main: "index.node",
+            files: ["index.node"],
+            neon: {
+                type: "binary",
+                rust: rust,
+                node: targetInfo.node,
+                os: targetInfo.os,
+                arch: targetInfo.arch,
+                abi: targetInfo.abi
+            }
+        };
+        this.manifest.copyOptionalKeys(json);
+        return new BinaryManifest(json);
+    }
+    async makeBinaryPackage(node, rust, log) {
+        const binaryManifest = this.manifestFor(node, rust);
+        log(`prebuild manifest: ${binaryManifest.stringify()}`);
+        const treeDir = path.join(this.outDir, node);
+        log(`creating ${treeDir}`);
+        await fs.mkdir(treeDir, { recursive: true });
+        log(`created ${treeDir}`);
+        log(`creating ${treeDir}/package.json`);
+        await binaryManifest.save(treeDir, log);
+        log(`creating ${treeDir}/README.md`);
+        await fs.writeFile(path.join(treeDir, "README.md"), `# \`${binaryManifest.name}\`\n\n${binaryManifest.description}\n`);
+    }
+    async updateBinaryManifest(node, rust, log) {
+        const targetInfo = (0, platform_cjs_1.describeTarget)(rust);
+        const dir = path.join(this.outDir, node);
+        const binaryManifest = await BinaryManifest.load(dir);
+        binaryManifest.setTarget(rust, targetInfo);
+        await binaryManifest.save(dir, log);
+    }
+    async saveChanges(dir, changes, log) {
+        const newPlatforms = [];
+        for (const change of changes) {
+            switch (change.kind) {
+                case change_cjs_1.EventKind.PLATFORM_ADDED: {
+                    await this.makeBinaryPackage(change.event.node, change.event.rust, log);
+                    break;
+                }
+                case change_cjs_1.EventKind.PLATFORM_MODIFIED: {
+                    await this.updateBinaryManifest(change.event.node, change.event.rust, log);
+                    break;
+                }
+                default:
+                    continue;
+            }
+        }
+        if (newPlatforms.length) {
+            await this.updateLoader(newPlatforms);
+        }
+    }
+    async updateLoader(platforms) {
+        const cfg = this.manifest.cfg();
+        if (!cfg.load) {
+            return;
+        }
+        const loader = await fs.readFile(cfg.load, 'utf8');
+        function isPlatformTable(p) {
+            return p.value.properties.every(p => {
+                return p.type === 'Property' &&
+                    p.key.type === 'Literal' &&
+                    (0, platform_cjs_1.isNodePlatform)(p.key.value);
+            });
+        }
+        const result = (0, jscodeshift_1.default)(loader)
+            .find(jscodeshift_1.default.ObjectExpression)
+            .filter(isPlatformTable)
+            .replaceWith((p) => {
+            const newProps = platforms.map(platform => {
+                return jscodeshift_1.default.property('init', jscodeshift_1.default.literal(platform), jscodeshift_1.default.arrowFunctionExpression([], jscodeshift_1.default.callExpression(jscodeshift_1.default.identifier('require'), [jscodeshift_1.default.literal(`${cfg.org}/${platform}`)])));
+            });
+            return jscodeshift_1.default.objectExpression([...p.value.properties, ...newProps]);
+        })
+            .toSource({ quote: 'single' });
+        await fs.writeFile(cfg.load, result, 'utf8');
+    }
+}
+exports.NPMCacheCfg = NPMCacheCfg;
+function assertIsBinaryCfg(json) {
+    (0, util_cjs_1.assertHasProps)(['type', 'rust', 'node', 'os', 'arch', 'abi'], json, "neon");
+    if (json.type !== 'binary') {
+        throw new TypeError(`expected "neon.type" property to be "binary", found ${json.type}`);
+    }
+    if (typeof json.rust !== 'string' || !(0, platform_cjs_1.isRustTarget)(json.rust)) {
+        throw new TypeError(`expected "neon.rust" to be a valid Rust target, found ${json.rust}`);
+    }
+    if (typeof json.node !== 'string' || !(0, platform_cjs_1.isNodePlatform)(json.node)) {
+        throw new TypeError(`expected "neon.node" to be a valid Node target, found ${json.node}`);
+    }
+    if (typeof json.os !== 'string') {
+        throw new TypeError(`expected "neon.os" to be a string, found ${json.os}`);
+    }
+    if (typeof json.arch !== 'string') {
+        throw new TypeError(`expected "neon.arch" to be a string, found ${json.arch}`);
+    }
+    if (json.abi !== null && typeof json.abi !== 'string') {
+        throw new TypeError(`expected "neon.abi" to be a string or null, found ${json.abi}`);
+    }
+}
+function assertIsBinaryV2(json) {
+    if (!json || typeof json !== 'object') {
+        throw new TypeError(`expected "neon" to be an object, found ${json}`);
+    }
+    (0, util_cjs_1.assertHasProps)(['rust', 'node', 'platform', 'arch', 'abi'], json, "neon");
+    if (!(0, platform_cjs_1.isRustTarget)(json.rust)) {
+        throw new TypeError(`expected "neon.rust" to be a valid Rust target, found ${json.rust}`);
+    }
+    if (!(0, platform_cjs_1.isNodePlatform)(json.node)) {
+        throw new TypeError(`expected "neon.node" to be a valid Node platform, found ${json.node}`);
+    }
+    if (typeof json.platform !== 'string') {
+        throw new TypeError(`expected "neon.platform" to be a string, found ${json.platform}`);
+    }
+    if (typeof json.arch !== 'string') {
+        throw new TypeError(`expected "neon.arch" to be a string, found ${json.arch}`);
+    }
+    if (json.abi !== null && typeof json.abi !== 'string') {
+        throw new TypeError(`expected "neon.abi" to be a string or null, found ${json.abi}`);
+    }
+}
+function assertIsBinaryV1(json) {
+    (0, util_cjs_1.assertHasProps)(['binary'], json, "neon");
+    const binary = json.binary;
+    if (!binary || typeof binary !== 'object') {
+        throw new TypeError(`expected "neon.binary" to be an object, found ${binary}`);
+    }
+    (0, util_cjs_1.assertHasProps)(['rust', 'node', 'platform', 'arch', 'abi'], binary, "neon.binary");
+    if (typeof binary.rust !== 'string' || !(0, platform_cjs_1.isRustTarget)(binary.rust)) {
+        throw new TypeError(`expected "neon.binary.rust" to be a valid Rust target, found ${binary.rust}`);
+    }
+    if (!(0, platform_cjs_1.isNodePlatform)(binary.node)) {
+        throw new TypeError(`expected "neon.binary.node" to be a valid Node platform, found ${binary.node}`);
+    }
+    if (typeof binary.platform !== 'string') {
+        throw new TypeError(`expected "neon.binary.platform" to be a string, found ${binary.platform}`);
+    }
+    if (typeof binary.arch !== 'string') {
+        throw new TypeError(`expected "neon.binary.arch" to be a string, found ${binary.arch}`);
+    }
+    if (binary.abi !== null && typeof binary.abi !== 'string') {
+        throw new TypeError(`expected "neon.binary.abi" to be a string or null, found ${binary.abi}`);
+    }
+}
+function assertHasBinaryCfg(json) {
+    (0, neon_cjs_1.assertHasNeonCfg)(json);
+    assertIsBinaryCfg(json.neon);
+}
+class BinaryManifest extends abstract_cjs_1.AbstractManifest {
+    constructor(json) {
+        super(json);
+        if (normalizeBinaryCfg(this._json)) {
+            this._changes.push({
+                kind: change_cjs_1.EventKind.SCHEMA_UPGRADED,
+                event: new change_cjs_1.SchemaUpgradedEvent('3')
+            });
+        }
+        assertHasBinaryCfg(this._json);
+        this._binaryJSON = this._json;
+    }
+    cfg() {
+        return this._binaryJSON.neon;
+    }
+    setTarget(target, targetInfo) {
+        const json = this._json;
+        json.os = targetInfo.os;
+        json.cpu = targetInfo.arch;
+        this._binaryJSON.neon.rust = target;
+        this._binaryJSON.neon.os = targetInfo.os;
+        this._binaryJSON.neon.arch = targetInfo.arch;
+        this._binaryJSON.neon.abi = targetInfo.abi;
+    }
+    static async load(dir) {
+        return new BinaryManifest(await (0, abstract_cjs_1.readManifest)(dir));
+    }
+}
+exports.BinaryManifest = BinaryManifest;
+function normalizeBinaryCfg(json) {
+    (0, neon_cjs_1.assertHasNeonCfg)(json);
+    // V3 format: {
+    //   neon: {
+    //     type: 'binary',
+    //     rust: RustTarget,
+    //     node: NodeTarget,
+    //     os: string,
+    //     arch: string,
+    //     abi: string | null
+    //   }
+    // }
+    if ('type' in json.neon && 'os' in json.neon) {
+        return false;
+    }
+    // V2 format: {
+    //   neon: {
+    //     type: 'binary',
+    //     rust: RustTarget,
+    //     node: NodeTarget,
+    //     platform: string,
+    //     arch: string,
+    //     abi: string | null
+    //   }
+    // }
+    if ('type' in json.neon) {
+        json.neon = upgradeBinaryV2(json.neon);
+        return true;
+    }
+    // V1 format: {
+    //   neon: {
+    //     binary: {
+    //       rust: RustTarget,
+    //       node: NodeTarget,
+    //       platform: string,
+    //       arch: string,
+    //       abi: string | null
+    //     }
+    //   }
+    // }
+    json.neon = upgradeBinaryV1(json.neon);
+    return true;
+}
+function upgradeBinaryV1(json) {
+    assertIsBinaryV1(json);
+    return {
+        type: 'binary',
+        rust: json.binary.rust,
+        node: json.binary.node,
+        os: json.binary.platform,
+        arch: json.binary.arch,
+        abi: json.binary.abi
+    };
+}
+function upgradeBinaryV2(json) {
+    assertIsBinaryV2(json);
+    return {
+        type: 'binary',
+        rust: json.rust,
+        node: json.node,
+        os: json.platform,
+        arch: json.arch,
+        abi: json.abi
+    };
+}

package/lib/cache/npm.d.cts

@@ -0,0 +1,31 @@
+import { CacheCfg } from '../cache.cjs';
+import { Change } from '../change.cjs';
+import { LibraryManifest } from '../index.cjs';
+import { RustTarget, NodePlatform, PlatformDescriptor } from '../platform.cjs';
+import { AbstractManifest } from '../abstract.cjs';
+export declare class NPMCacheCfg implements CacheCfg {
+    readonly type: string;
+    private manifest;
+    private outDir;
+    constructor(manifest: LibraryManifest, outDir?: string);
+    manifestFor(node: NodePlatform, rust: RustTarget): BinaryManifest;
+    makeBinaryPackage(node: NodePlatform, rust: RustTarget, log: (msg: string) => void): Promise<void>;
+    updateBinaryManifest(node: NodePlatform, rust: RustTarget, log: (msg: string) => void): Promise<void>;
+    saveChanges(dir: string, changes: Change[], log: (msg: string) => void): Promise<void>;
+    updateLoader(platforms: NodePlatform[]): Promise<void>;
+}
+export interface BinaryCfg {
+    type: "binary";
+    rust: RustTarget;
+    node: NodePlatform;
+    os: string;
+    arch: string;
+    abi: string | null;
+}
+export declare class BinaryManifest extends AbstractManifest {
+    private _binaryJSON;
+    constructor(json: unknown);
+    cfg(): BinaryCfg;
+    setTarget(target: RustTarget, targetInfo: PlatformDescriptor): void;
+    static load(dir?: string | undefined): Promise<BinaryManifest>;
+}

package/lib/cache.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cache.d.cts

@@ -0,0 +1,5 @@
+import { Change } from './change.cjs';
+export interface CacheCfg {
+    readonly type: string;
+    saveChanges(dir: string, changes: Change[], log: (msg: string) => void): Promise<void>;
+}

package/lib/change.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestChangedEvent = exports.PlatformModifiedEvent = exports.PlatformAddedEvent = exports.SchemaUpgradedEvent = exports.EventKind = void 0;
+var EventKind;
+(function (EventKind) {
+    EventKind[EventKind["SCHEMA_UPGRADED"] = 0] = "SCHEMA_UPGRADED";
+    EventKind[EventKind["PLATFORM_ADDED"] = 1] = "PLATFORM_ADDED";
+    EventKind[EventKind["PLATFORM_MODIFIED"] = 2] = "PLATFORM_MODIFIED";
+    EventKind[EventKind["MANIFEST_CHANGED"] = 3] = "MANIFEST_CHANGED";
+})(EventKind || (exports.EventKind = EventKind = {}));
+class SchemaUpgradedEvent {
+    constructor(schemaVersion) {
+        this.schemaVersion = schemaVersion;
+    }
+    description() {
+        return `Neon manifest schema v${this.schemaVersion} upgrade`;
+    }
+}
+exports.SchemaUpgradedEvent = SchemaUpgradedEvent;
+class PlatformAddedEvent {
+    constructor(node, rust) {
+        this.node = node;
+        this.rust = rust;
+    }
+    description() {
+        return `added ${this.node} platform`;
+    }
+}
+exports.PlatformAddedEvent = PlatformAddedEvent;
+class PlatformModifiedEvent {
+    constructor(node, rust) {
+        this.node = node;
+        this.rust = rust;
+    }
+    description() {
+        return `modified ${this.node} platform to ${this.rust} target`;
+    }
+}
+exports.PlatformModifiedEvent = PlatformModifiedEvent;
+class ManifestChangedEvent {
+    constructor(version) {
+        this.version = version;
+    }
+    description() {
+        return `update platforms to v${this.version}`;
+    }
+}
+exports.ManifestChangedEvent = ManifestChangedEvent;

package/lib/change.d.cts

@@ -0,0 +1,49 @@
+import { NodePlatform, RustTarget } from "./platform.cjs";
+export declare enum EventKind {
+    SCHEMA_UPGRADED = 0,
+    PLATFORM_ADDED = 1,
+    PLATFORM_MODIFIED = 2,
+    MANIFEST_CHANGED = 3
+}
+export type SchemaUpgraded = {
+    kind: EventKind.SCHEMA_UPGRADED;
+    event: SchemaUpgradedEvent;
+};
+export type PlatformAdded = {
+    kind: EventKind.PLATFORM_ADDED;
+    event: PlatformAddedEvent;
+};
+export type PlatformModified = {
+    kind: EventKind.PLATFORM_MODIFIED;
+    event: PlatformModifiedEvent;
+};
+export type ManifestChanged = {
+    kind: EventKind.MANIFEST_CHANGED;
+    event: ManifestChangedEvent;
+};
+export type Change = SchemaUpgraded | PlatformAdded | PlatformModified | ManifestChanged;
+export interface Event {
+    description(): string;
+}
+export declare class SchemaUpgradedEvent implements Event {
+    private schemaVersion;
+    constructor(schemaVersion: string);
+    description(): string;
+}
+export declare class PlatformAddedEvent implements Event {
+    readonly node: NodePlatform;
+    readonly rust: RustTarget;
+    constructor(node: NodePlatform, rust: RustTarget);
+    description(): string;
+}
+export declare class PlatformModifiedEvent implements Event {
+    readonly node: NodePlatform;
+    readonly rust: RustTarget;
+    constructor(node: NodePlatform, rust: RustTarget);
+    description(): string;
+}
+export declare class ManifestChangedEvent implements Event {
+    private version;
+    constructor(version: string);
+    description(): string;
+}