npm-pkgbuild 10.0.1 → 10.1.0

package/README.md

@@ -36,17 +36,18 @@ You can specify the package content in package.json.
 {
 	"pkgbuild": {
 		"content": {
-			"/some/location" : { "base": "build" },
+			"/some/location/" : { "base": "build" },
 			"/etc/myconfig.json" : "sample-config.json",
-            "/opt/myapp": [
-                {
-                "type": "npm-pack"
-                },
-                {
-                "type": "node-modules",
-                "withoutDevelpmentDependencies": true
-                }
-            ]
+			"/erc/secret" : { "name":  "secret", "mode": "600" },
+      "/opt/myapp": [
+        {
+          "type": "npm-pack"
+        },
+        {
+          "type": "node-modules",
+          "withoutDevelpmentDependencies": true
+        }
+      ]
 		},
 		"hooks" : "pkg/hooks",
 		"output": {
@@ -61,7 +62,7 @@ You can specify the package content in package.json.
 
 # content providers
 
-# files (default)
+## files (default)
 
 content from the file system
 
@@ -76,6 +77,10 @@ content of all (production) dependencies
 options:
     - withoutDevelpmentDependencies when to stip away dev dependencies (defaults to true)
 
+# shared configuration
+
+You can import common configuration from other packages
+see mf-hosting module as an example
 
 # API
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "10.0.1",
+  "version": "10.1.0",
   "publishConfig": {
     "access": "public"
   },
@@ -52,10 +52,10 @@
     "ini": "^3.0.0",
     "iterable-string-interceptor": "^2.0.0",
     "key-value-transformer": "^3.0.0",
-    "node-fetch": "^3.2.3",
+    "node-fetch": "^3.2.4",
     "npm-package-walker": "^5.0.6",
-    "npm-packlist": "^5.0.2",
-    "pacote": "^13.1.1",
+    "npm-packlist": "^5.0.3",
+    "pacote": "^13.3.0",
     "pkg-dir": "^6.0.1",
     "tar-stream": "^2.2.0"
   },

package/src/content/file-content-provider.mjs

@@ -33,6 +33,18 @@ export class FileContentProvider extends ContentProvider {
     }
 
     this.entryProperties = entryProperties;
+
+    if(this.entryProperties) {
+    for(const a of ["mode"]) {
+      if(this.entryProperties[a] !== undefined) {
+        if(!this.baseProperties) {
+          this.baseProperties = {};
+        }
+    	this.baseProperties[a] = { value: this.entryProperties[a] };
+    	delete this.entryProperties[a];
+      }
+    }
+    }
   }
 
   toString() {
@@ -46,10 +58,12 @@ export class FileContentProvider extends ContentProvider {
     for (const name of await globby(definitions.pattern, {
       cwd: base
     })) {
-      yield Object.assign(
+      const entry = Object.assign(
         new FileSystemEntry(name, base),
         this.entryProperties
       );
+
+      yield this.baseProperties ? Object.create(entry, this.baseProperties) : entry;
     }
   }
 }

package/src/extract-from-package.mjs

@@ -1,4 +1,3 @@
-import { arch as hostArch } from "process";
 import { packageWalker } from "npm-package-walker";
 import { createContext } from "expression-expander";
 import { asArray } from "./util.mjs";
@@ -12,29 +11,52 @@ import { RPM } from "./output/rpm.mjs";
 export const allInputs = [NPMPackContentProvider, NodeModulesContentProvider];
 export const allOutputs = [DEBIAN, ARCH, RPM];
 
+/**
+ * Node architecture name to os native name mapping
+ * {@see https://nodejs.org/dist/latest-v18.x/docs/api/process.html#processargv}
+ */
 export const npmArchMapping = {
   arm64: "aarch64",
   arm: "armv7h",
-  x64: "x86_64"
+  mips: "mips",
+  mipsel: "mipsel",
+  ppc: "ppc",
+  s390: "s390",
+  s390x: "s390x",
+  ia32: "x32",
+  x64: "x86_64",
+  ppc64: "ppc64"
 };
 
-export const archMapping = Object.fromEntries(
-  Object.entries(npmArchMapping).map(a => [a[1], a[0]])
-);
+const entryAttributeNames = ["owner", "group", "mode"];
+
+/**
+ * @typedef {Object} PackageDefinition 
+ * @property {Object} properties values describing the package attributes
+ * @property {ContentProvider[]} sources content providers
+ * @property {Object} dependencies
+ * @property {Object} output package type
+ * @property {string} variant identifier of the variant
+ */
 
 /**
  * Extract package definition from package.json.
+ * - for each architecture deliver a new result
+ * - if not architecture is given one result set is provided nethertheless
+ * - architectures are taken from cpu (node arch ids) and from pkgbuild.arch (raw arch ids)
  * @param {Object} pkg package.json content
  * @param {string} dir
- * @returns {Object}
+ * @returns {AsyncIter<PackageDefinition>}
  */
-export async function extractFromPackage(json, dir) {
+export async function* extractFromPackage(json, dir) {
   const properties = Object.fromEntries(
     ["name", "version", "description", "homepage", "license"]
       .map(key => [key, json[key]])
       .filter(([k, v]) => v !== undefined)
   );
 
+  let variant = "default";
+
   if (json.bugs) {
     if (json.bugs.url) {
       properties.bugs = json.bugs.url;
@@ -86,6 +108,10 @@ export async function extractFromPackage(json, dir) {
       }
 
       if (pkg.abstract || !modulePath) {
+        if (pkg.variant) {
+          variant = pkg.variant;
+        }
+
         if (pkg.arch) {
           for (const a of asArray(pkg.arch)) {
             arch.add(a);
@@ -99,31 +125,39 @@ export async function extractFromPackage(json, dir) {
           .forEach(([k, v]) => (properties[k] = v));
 
         if (pkg.content && !modulePath) {
-          Object.entries(pkg.content).forEach(
-            ([destination, definitions]) => {
-              destination = context.expand(destination);
-              definitions = context.expand(definitions);
-              for (const definition of asArray(definitions)) {
-                const entryProperties = { destination };
-
-                if (definition.type) {
-                  const type = allInputs.find(i => i.name === definition.type);
-                  if (type) {
-                    delete definition.type;
-                    sources.push(
-                      new type({ ...definition, dir }, entryProperties)
-                    );
-                  } else {
-                    console.error(`Unknown type '${type}'`);
-                  }
-                } else {
+          Object.entries(pkg.content).forEach(([destination, definitions]) => {
+            destination = context.expand(destination);
+            definitions = context.expand(definitions);
+
+            const allEntryProperties = {};
+
+            for (const a of entryAttributeNames) {
+              if (definitions[a] !== undefined) {
+                allEntryProperties[a] = definitions[a];
+                delete definitions[a];
+              }
+            }
+
+            for (const definition of asArray(definitions)) {
+              const entryProperties = { ...allEntryProperties, destination };
+
+              if (definition.type) {
+                const type = allInputs.find(i => i.name === definition.type);
+                if (type) {
+                  delete definition.type;
                   sources.push(
-                    new FileContentProvider(definition, entryProperties)
+                    new type({ ...definition, dir }, entryProperties)
                   );
+                } else {
+                  console.error(`Unknown type '${type}'`);
                 }
+              } else {
+                sources.push(
+                  new FileContentProvider(definition, entryProperties)
+                );
               }
             }
-          );
+          });
         }
       }
       Object.assign(dependencies, pkg.depends);
@@ -139,9 +173,16 @@ export async function extractFromPackage(json, dir) {
 
   processPkg(json, dir);
 
+  properties.variant = variant;
+
   if (arch.size > 0) {
-    properties.arch = [...arch].filter(a => a === npmArchMapping[hostArch]);
+    // provide each arch separadly
+    for (const a of arch) {
+      properties.arch = [a];
+      yield { properties, sources, dependencies, output, variant };
+    }
+  } else {
+    // or one set if no arch is given
+    yield { properties, sources, dependencies, output, variant };
   }
-
-  return { properties, sources, dependencies, output };
 }

package/src/npm-pkgbuild-cli.mjs

@@ -75,73 +75,82 @@ program
         console.log(`pkgdir: ${pkgDir}`);
       }
 
-      const { properties, sources, output, dependencies } =
-        await extractFromPackage(
-          JSON.parse(
-            await readFile(join(pkgDir, "package.json"), utf8StreamOptions)
-          ),
-          pkgDir
-        );
-
-      for (const inputFactory of allInputs.filter(
-        inputFactory => options[inputFactory.name] === true
+      for await (const {
+        properties,
+        sources,
+        output,
+        dependencies,
+        variant
+      } of extractFromPackage(
+        JSON.parse(
+          await readFile(join(pkgDir, "package.json"), utf8StreamOptions)
+        ),
+        pkgDir
       )) {
-        sources.push(new inputFactory());
-      }
-
-      for (const outputFactory of allOutputs.filter(
-        o => options[o.name] === true || output[o.name] !== undefined
-      )) {
-        if (options.available && !(await outputFactory.available)) {
-          continute;
+        for (const inputFactory of allInputs.filter(
+          inputFactory => options[inputFactory.name] === true
+        )) {
+          sources.push(new inputFactory());
         }
 
-        Object.assign(properties, { type: outputFactory.name }, options.define);
-
-        sources.push(
-          ...[...options.content, ...options.meta]
-            .filter(x => x)
-            .map(
-              source =>
-                new FileContentProvider({
-                  base: source
-                })
+        for (const outputFactory of allOutputs.filter(
+          o => options[o.name] === true || output[o.name] !== undefined
+        )) {
+          if (options.available && !(await outputFactory.available)) {
+            continute;
+          }
+
+          Object.assign(
+            properties,
+            { type: outputFactory.name },
+            options.define
+          );
+
+          sources.push(
+            ...[...options.content, ...options.meta]
+              .filter(x => x)
+              .map(
+                source =>
+                  new FileContentProvider({
+                    base: source
+                  })
+              )
+          );
+
+          const context = createContext({ properties });
+          const output = new outputFactory(context.expand(properties));
+          const transformer = [
+            createExpressionTransformer(
+              nameExtensionMatcher([
+                ".conf",
+                ".json",
+                ".html",
+                ".txt",
+                ".webmanifest",
+                ".service",
+                ".socket",
+                ".rules"
+              ]),
+              context.expand(properties)
             )
-        );
-
-        const context = createContext({ properties });
-        const output = new outputFactory(context.expand(properties));
-        const transformer = [
-          createExpressionTransformer(
-            nameExtensionMatcher([
-              ".conf",
-              ".json",
-              ".html",
-              ".txt",
-              ".webmanifest",
-              ".service",
-              ".socket",
-              ".rules"
-            ]),
-            context.expand(properties)
-          )
-        ];
-
-        if (options.verbose) {
-          console.log(output.properties);
-          console.log(`sources: ${sources.join("\n  ")}`);
-          console.log(`dependencies: ${JSON.stringify(dependencies)}`);
+          ];
+
+          if (options.verbose) {
+            console.log(output.properties);
+            console.log(`sources: ${sources.join("\n  ")}`);
+            console.log(`dependencies: ${JSON.stringify(dependencies)}`);
+          }
+
+          const fileName = await output.execute(
+            sources.map(c => c[Symbol.asyncIterator]()),
+            transformer,
+            dependencies,
+            options,
+            path => context.expand(path)
+          );
+
+          await publish(fileName, options.publish, properties);
         }
-
-        const fileName = await output.execute(
-          sources.map(c => c[Symbol.asyncIterator]()),
-          transformer,
-          dependencies,
-          options,
-          path => context.expand(path)
-        );
-
-        await publish(fileName, options.publish, properties);
       }
     } catch (e) {
       console.error(e);

package/src/util.mjs

@@ -144,7 +144,7 @@ export function fieldProvider(properties, fields) {
 
 /**
  * Copy content from source into destinationDirectory.
- * Destination paths a generated without leading '/' (as for as entry names too).
+ * Destination paths a generated without leading '/' (as for entry names too).
  * @param {AsyncIterator<ContentEntry>} source
  * @param {string} destinationDirectory
  * @param {Expander} expander