npm-pkgbuild 7.5.0 → 7.7.2

package/README.md

@@ -11,7 +11,7 @@
 
 ## npm-pkgbuild
 
-create ArchLinux packages from npm packages
+create ArchLinux, RPM and debian packages from npm packages.
 
 # usage
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.5.0",
+  "version": "7.7.2",
   "publishConfig": {
     "access": "public"
   },
@@ -8,7 +8,7 @@
   "exports": {
     ".": "./src/module.mjs"
   },
-  "description": "create packages from npm packages",
+  "description": "create ArchLinux, RPM and debian packages from npm packages",
   "keywords": [
     "ArchLinux",
     "arch-linux",
@@ -40,13 +40,14 @@
   "dependencies": {
     "aggregate-async-iterator": "^1.1.7",
     "commander": "^8.3.0",
-    "content-entry": "^2.10.0",
-    "content-entry-filesystem": "^3.1.11",
+    "content-entry": "^3.0.1",
+    "content-entry-filesystem": "^3.1.14",
     "execa": "^6.0.0",
     "expression-expander": "^7.0.9",
     "globby": "^12.0.2",
     "iterable-string-interceptor": "^1.0.8",
     "key-value-transformer": "^2.0.0",
+    "npm-package-walker": "^5.0.3",
     "npm-packlist": "^3.0.0",
     "pacote": "^12.0.2",
     "pkg-dir": "^6.0.1",

package/src/npm-pkgbuild-cli.mjs

@@ -17,11 +17,11 @@ const { version, description } = JSON.parse(
 
 const cwd = process.cwd();
 
-const outputs = [DEB, PKG, RPM];
+const allOutputs = [DEB, PKG, RPM];
 
 program.description(description).version(version);
 
-outputs.forEach(o =>
+allOutputs.forEach(o =>
   program.option(`--${o.name}`, `generate ${o.name} package`)
 );
 
@@ -46,18 +46,21 @@ program
   )
   .action(async options => {
     try {
-      for (const outputFactory of outputs.filter(
-        o => options[o.name] === true
-      )) {
-        const { properties, sources } = extractFromPackage(
-          JSON.parse(
-            await readFile(
-              join(await packageDirectory(), "package.json"),
-              utf8StreamOptions
-            )
+      const pkgDir = await packageDirectory();
+
+      const { properties, sources, output } = await extractFromPackage(
+        JSON.parse(
+          await readFile(
+            join(pkgDir, "package.json"),
+            utf8StreamOptions
           )
-        );
+        ),
+        pkgDir
+      );
 
+      for (const outputFactory of allOutputs.filter(
+        o => options[o.name] === true || output[o.name] !== undefined
+      )) {
         Object.assign(properties, options.define);
 
         sources.push(

package/src/output/deb.mjs

@@ -58,7 +58,8 @@ export class DEB extends Packager {
 
     await copyEntries(transform(sources, transformers), staging, expander, attributes);
 
-    await execa("dpkg", ["-b", staging, options.destination]);
+    const dpkg = await execa("dpkg", ["-b", staging, options.destination]);
+    //console.log(dpkg.stdout);
 
     return join(options.destination, this.packageFileName);
   }
@@ -81,7 +82,7 @@ const fields = {
   Architecture: {
     alias: "arch",
     type: "string",
-    default: "any",
+    default: "all",
     mandatory: true
   },
   Homepage: { alias: "homepage", type: "string" },

package/src/output/packager.mjs

@@ -2,15 +2,14 @@ import { join } from "path";
 import { tmpdir } from "os";
 import { mkdtemp } from "fs/promises";
 
-
 /**
  * @typedef {Object} Field
  * @property {string} alias interchangeable field name
  * @property {string} type
  * @property {any} default
- * @property {boolean} mandatory 
+ * @property {boolean} mandatory
  */
- 
+
 /**
  * @param {Object} properties
  */
@@ -61,13 +60,12 @@ export class Packager {
    * Create tmp directory.
    * @return {Promise<string>} directory path
    */
-  get tmpdir()
-  {
+  get tmpdir() {
     return mkdtemp(join(tmpdir(), this.constructor.name));
   }
 
   /**
    * Execute package generation
    */
-  async execute(sources,options) {}
+  async execute(sources, options) {}
 }

package/src/output/pkg.mjs

@@ -7,7 +7,7 @@ import {
 } from "key-value-transformer";
 import { Packager } from "./packager.mjs";
 import { copyEntries, transform } from "../util.mjs";
-import { quote } from "../util.mjs";
+import { quote, createExpressionTransformer } from "../util.mjs";
 
 /**
  * @type KeyValueTransformOptions
@@ -45,10 +45,10 @@ export class PKG extends Packager {
 
   get packageFileName() {
     const p = this.properties;
-    return `${p.name}-${p.version}-${p.release}.${p.arch}${this.constructor.fileNameExtension}`;
+    return `${p.name}-${p.version}-${p.release}-${p.arch}${this.constructor.fileNameExtension}`;
   }
 
-  async execute(sources, options,expander) {
+  async execute(sources, options, expander) {
     const properties = this.properties;
 
     //properties.depends = makeDepends({ ...pkg.engines });
@@ -77,7 +77,7 @@ package() {
 `;
     }
 
-    await copyEntries(transform(sources, []), join(staging, "src"), expander);
+    await copyEntries(transform(sources, [createExpressionTransformer(properties)]), join(staging, "src"), expander);
 
     const metaTransformers = [
       {
@@ -94,9 +94,16 @@ package() {
       }
     ];
 
-    await copyEntries(transform(sources, metaTransformers, true), staging, expander);
+    await copyEntries(
+      transform(sources, metaTransformers, true),
+      staging,
+      expander
+    );
 
-    await execa("makepkg", ["-f"], { cwd: staging });
+    await execa("makepkg", ["-f"], {
+      cwd: staging,
+      env: { PKGDEST: options.destination }
+    });
 
     return join(options.destination, this.packageFileName);
   }

package/src/output/rpm.mjs

@@ -1,5 +1,5 @@
 import { join } from "path";
-import { mkdir } from "fs/promises";
+import { mkdir, cp } from "fs/promises";
 import { execa } from "execa";
 import { EmptyContentEntry, ReadableStreamContentEntry } from "content-entry";
 import {
@@ -78,7 +78,7 @@ export class RPM extends Packager {
 
     await copyEntries(transform(sources, transformers), staging, expander);
 
-    await execa("rpmbuild", [
+    const rpmbuild = await execa("rpmbuild", [
       "--define",
       `_topdir ${tmp}`,
       "-vv",
@@ -86,6 +86,11 @@ export class RPM extends Packager {
       join(staging, specFileName)
     ]);
 
+    await cp(
+      join(tmp, "RPMS", properties.arch, this.packageFileName),
+      join(options.destination, this.packageFileName),
+      {preserveTimestamps :true }
+    );
     return join(options.destination, this.packageFileName);
   }
 }

package/src/util.mjs

@@ -2,8 +2,10 @@ import { join, dirname } from "path";
 import { mkdir } from "fs/promises";
 import { pipeline } from "stream/promises";
 import { createWriteStream } from "fs";
-
+import { iterableStringInterceptor } from "iterable-string-interceptor";
+import { ReadableStreamContentEntry } from "content-entry";
 import { FileContentProvider } from "npm-pkgbuild";
+import { packageWalker } from "npm-package-walker";
 
 export const utf8StreamOptions = { encoding: "utf8" };
 
@@ -26,9 +28,10 @@ export function asArray(o) {
 /**
  * Extract package definition from package.json.
  * @param {Object} pkg package.json content
+ * @param {string} dir
  * @returns {Object}
  */
-export function extractFromPackage(pkg) {
+export async function extractFromPackage(pkg, dir) {
   const properties = Object.fromEntries(
     ["name", "version", "description", "homepage"]
       .map(key => [key, pkg[key]])
@@ -55,30 +58,64 @@ export function extractFromPackage(pkg) {
 
   let dependencies = { ...pkg.engines };
   let sources = [];
+  let output = {};
+
+  const processPkg = pkg => {
+    if (pkg.pkgbuild) {
+      const pkgbuild = pkg.pkgbuild;
+
+      Object.assign(output, pkgbuild.output);
+
+      Object.entries(pkgbuild)
+        .filter(([k, v]) => typeof v === "string")
+        .forEach(([k, v]) => (properties[k] = v));
+
+      if (pkgbuild.content) {
+        sources = Object.entries(pkgbuild.content).map(
+          ([destination, value]) =>
+            new FileContentProvider(value, { destination })
+        );
+      }
 
-  if (pkg.pkgbuild) {
-    const pkgbuild = pkg.pkgbuild;
-    Object.entries(pkgbuild)
-      .filter(([k, v]) => typeof v === "string")
-      .forEach(([k, v]) => (properties[k] = v));
-
-    if (pkgbuild.content) {
-      sources = Object.entries(pkgbuild.content).map(
-        ([destination, value]) =>
-          new FileContentProvider(value, { destination })
-      );
+      Object.assign(dependencies, pkgbuild.depends);
     }
+  };
+
+  await packageWalker(async (pkg, base, modulePath) => {
+    processPkg(pkg);
+    return true;
+  }, dir);
+
+  processPkg(pkg);
+
+  return { properties, sources, dependencies, output };
+}
 
-    Object.assign(dependencies, pkgbuild.depends);
+export function createExpressionTransformer(properties) {
+  async function* transformer(expression, remainder, source, cb) {
+    const value = properties[expression];
+    console.log("EXPRESSION", expression, value);
+    yield value === undefined ? "" : value;
   }
 
-  return { properties, sources, dependencies };
+  return {
+    match: entry => true, //entry.name.match(/(conf|json)$/),
+    transform: async entry =>
+      new ReadableStreamContentEntry(
+        entry.name,
+        iterableStringInterceptor(
+          await entry.getReadStream(utf8StreamOptions),
+          transformer
+        )
+      )
+  };
 }
 
 /**
- * Apply transformers
+ * Apply transformers.
  * @param {AsyncIterator<ContentEntry>} source
  * @param {Transformer[]} transformers
+ * @param {Boolean]} onlyMatching filter out all none matching entries
  */
 export async function* transform(source, transformers = [], onlyMatching) {
   const usedTransformers = new Set();