dependency-owners 1.0.0

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025 Kirk Eaton
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,3 @@
+# dependency-owners
+
+Determine ownership of dependencies in a project.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { buildApplication, buildCommand, run, } from '@stricli/core';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { dependencyOwners } from './index.js';
+import { getErrorMessage } from './utils.js';
+const { name, version, description } = createRequire(import.meta.url)('../package.json');
+function cwdParser(rawInput) {
+    return this.path.join(this.process.cwd(), rawInput);
+}
+const command = buildCommand({
+    async func(flags, dependencyFile) {
+        try {
+            const result = await dependencyOwners({
+                configFile: flags.config,
+                dependencies: flags.dependency,
+                dependencyFile,
+                loader: flags.loader,
+            });
+            this.process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        catch (error) {
+            const errorMessage = getErrorMessage(error);
+            this.process.stderr.write(`\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m\n`);
+            this.process.exit(1);
+        }
+    },
+    parameters: {
+        flags: {
+            config: {
+                kind: 'parsed',
+                brief: 'Path to the configuration file.',
+                default: 'dependency-owners.json',
+                parse: cwdParser,
+            },
+            dependency: {
+                kind: 'parsed',
+                parse: String,
+                brief: 'List of dependencies to check.',
+                optional: true,
+                variadic: true,
+            },
+            loader: {
+                kind: 'parsed',
+                parse: String,
+                brief: 'Loader to use for loading dependencies.',
+                optional: true,
+            },
+        },
+        positional: {
+            kind: 'tuple',
+            parameters: [
+                {
+                    brief: 'Path to the dependency file.',
+                    placeholder: 'dependency-file',
+                    default: 'package.json',
+                    parse: cwdParser,
+                },
+            ],
+        },
+    },
+    docs: {
+        brief: description,
+    },
+});
+const app = buildApplication(command, {
+    name,
+    versionInfo: {
+        currentVersion: version,
+    },
+});
+await run(app, process.argv.slice(2), { path, process });

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { DependencyLoader } from './loader.js';
+/**
+ * Options for the dependency owners lookup.
+ */
+export interface DependencyOwnersOptions {
+    /**
+     * Path to the dependency file.
+     */
+    dependencyFile?: string;
+    /**
+     * Path to the configuration file.
+     */
+    configFile?: string;
+    /**
+     * List of dependencies to check.
+     */
+    dependencies?: string[];
+    /**
+     * Loader to use for loading dependencies.
+     */
+    loader?: string | DependencyLoader;
+}
+/**
+ * Get the owners of the specified dependencies.
+ * @param {Options} options - The options for the dependency owners lookup.
+ * @returns {Promise<Record<string, string[]>>} A mapping of dependency owners for the specified dependencies.
+ */
+export declare function dependencyOwners(options: DependencyOwnersOptions): Promise<Record<string, string[]>>;

package/dist/index.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getOwners, getOwnersMapping, resolveDependencyLoader, } from './utils.js';
+/**
+ * Loader for loading dependencies from package.json files.
+ */
+const PackageJsonLoader = {
+    async canLoad(filePath) {
+        return path.basename(filePath) === 'package.json';
+    },
+    async load(filePath) {
+        const pkg = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+        return [
+            ...Object.keys(pkg.dependencies || {}),
+            ...Object.keys(pkg.devDependencies || {}),
+        ];
+    },
+};
+/**
+ * Get the owners of the specified dependencies.
+ * @param {Options} options - The options for the dependency owners lookup.
+ * @returns {Promise<Record<string, string[]>>} A mapping of dependency owners for the specified dependencies.
+ */
+export async function dependencyOwners(options) {
+    const { dependencies = [], loader = PackageJsonLoader, dependencyFile = path.join(process.cwd(), 'package.json'), configFile = path.join(process.cwd(), 'dependency-owners.json'), } = options;
+    const resolvedLoader = await resolveDependencyLoader(loader, dependencyFile);
+    if (!resolvedLoader) {
+        throw new Error(`No loader found for file: ${dependencyFile}`);
+    }
+    const ownersMapping = getOwnersMapping(configFile);
+    const resolvedDependencies = await resolvedLoader.load(dependencyFile);
+    const filteredDependencies = resolvedDependencies.filter((dep) => dependencies.length === 0 || dependencies.includes(dep));
+    return getOwners(filteredDependencies, ownersMapping);
+}

package/dist/loader.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Interface for loading dependencies from various file types.
+ */
+export interface DependencyLoader {
+    /**
+     * Check if the loader can handle the specified file.
+     * @param {string} filePath The path to the file to check.
+     * @returns {boolean} True if the loader can handle the file, false otherwise.
+     */
+    canLoad(filePath: string): Promise<boolean>;
+    /**
+     * Load the dependencies from the specified file.
+     * @param {string} filePath The path to the file to load dependencies from.
+     * @returns {string[]} The list of loaded dependencies.
+     */
+    load(filePath: string): Promise<string[]>;
+}

package/dist/loader.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+import { DependencyLoader } from './loader.js';
+/**
+ * Get the mapping of dependency owners from a JSON file.
+ * @param {string} filePath - The path to the dependency owners file.
+ * @returns {Record<string, string[]>} A mapping of dependency owners.
+ */
+export declare function getOwnersMapping(filePath: string): Record<string, string[]>;
+/**
+ * Get the owners of the specified dependencies.
+ * @param {string[]} dependencies - The list of dependencies to check.
+ * @param {Record<string, string[]>} ownersMapping - The mapping of dependency owners.
+ * @returns {Record<string, string[]>} A mapping of dependency owners for the specified dependencies.
+ */
+export declare function getOwners(dependencies: string[], ownersMapping: Record<string, string[]>): Record<string, string[]>;
+/**
+ * Resolve a dependency loader for a specific file.
+ * @param {DependencyLoader | string} loader The loader to use.
+ * @param {string} depFilePath The path to the dependency file.
+ * @returns {Promise<DependencyLoader | undefined>} The resolved dependency loader or undefined if not found.
+ */
+export declare function resolveDependencyLoader(loader: DependencyLoader | string, depFilePath: string): Promise<DependencyLoader | undefined>;
+/**
+ * Get a formatted error message.
+ * @param error The error to format.
+ * @returns The formatted error message.
+ */
+export declare function getErrorMessage(error: unknown): string;

package/dist/utils.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Get the mapping of dependency owners from a JSON file.
+ * @param {string} filePath - The path to the dependency owners file.
+ * @returns {Record<string, string[]>} A mapping of dependency owners.
+ */
+export function getOwnersMapping(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+/**
+ * Get the owners of the specified dependencies.
+ * @param {string[]} dependencies - The list of dependencies to check.
+ * @param {Record<string, string[]>} ownersMapping - The mapping of dependency owners.
+ * @returns {Record<string, string[]>} A mapping of dependency owners for the specified dependencies.
+ */
+export function getOwners(dependencies, ownersMapping) {
+    return dependencies.reduce((result, dep) => {
+        const owners = Object.keys(ownersMapping).filter((owner) => Array.isArray(ownersMapping[owner]) &&
+            ownersMapping[owner].includes(dep));
+        result[dep] = owners;
+        return result;
+    }, {});
+}
+/**
+ * Import a dependency loader by name.
+ * @param {string} loaderName The name of the loader to import.
+ * @returns {Promise<DependencyLoader>} The imported dependency loader.
+ */
+async function importDependencyLoader(loaderName) {
+    let loaderModule;
+    // Try importing from an installed dependency/absolute path
+    try {
+        loaderModule = await import(loaderName);
+    }
+    catch {
+        // no-op
+    }
+    // Try import from relative path
+    try {
+        loaderModule = await import(path.join(process.cwd(), loaderName));
+    }
+    catch {
+        // no-op
+    }
+    // If we couldn't find the module, throw an error
+    if (!loaderModule) {
+        throw new Error(`Failed to import loader: ${loaderName}`);
+    }
+    // Check if the loader has the required functions
+    const loader = loaderModule.default || loaderModule;
+    if (loader &&
+        typeof loader.canLoad === 'function' &&
+        typeof loader.load === 'function') {
+        return loader;
+    }
+    else {
+        throw new Error(`Invalid loader: ${loaderName}. The module does not export an object with 'canLoad' and 'load' functions.`);
+    }
+}
+/**
+ * Resolve a dependency loader for a specific file.
+ * @param {DependencyLoader | string} loader The loader to use.
+ * @param {string} depFilePath The path to the dependency file.
+ * @returns {Promise<DependencyLoader | undefined>} The resolved dependency loader or undefined if not found.
+ */
+export async function resolveDependencyLoader(loader, depFilePath) {
+    const resolvedLoader = typeof loader === 'string' ? await importDependencyLoader(loader) : loader;
+    const canLoad = await resolvedLoader.canLoad(depFilePath);
+    return canLoad ? resolvedLoader : undefined;
+}
+/**
+ * Get a formatted error message.
+ * @param error The error to format.
+ * @returns The formatted error message.
+ */
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "dependency-owners",
+  "version": "1.0.0",
+  "description": "Determine ownership of dependencies in a project",
+  "author": "Kirk Eaton <contact@kirkeaton.ca>",
+  "bin": "./dist/cli.js",
+  "dependencies": {
+    "@stricli/core": "1.2.0"
+  },
+  "devDependencies": {
+    "@kirkeaton/prettier-config": "1.0.5",
+    "@kirkeaton/semantic-release-config": "1.0.4",
+    "@kirkeaton/tsconfig": "1.0.3",
+    "@types/node": "24.2.1",
+    "fs-fixture": "2.8.1",
+    "prettier": "3.6.2",
+    "semantic-release": "24.2.7",
+    "tsx": "4.20.4",
+    "typescript": "5.9.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./loader": {
+      "types": "./dist/loader.d.ts",
+      "default": "./dist/loader.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "funding": "https://kirkeaton.ca/sponsor",
+  "homepage": "https://github.com/dependency-owners/dependency-owners#readme",
+  "keywords": [
+    "dependency",
+    "owners"
+  ],
+  "license": "BSD-3-Clause",
+  "packageManager": "pnpm@10.14.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dependency-owners/dependency-owners.git"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc",
+    "clean": "rm -rf dist",
+    "format": "prettier \"**/*.{js,json,md,ts}\" --write",
+    "lint": "prettier \"**/*.{js,json,md,ts,md}\" --check",
+    "prepublishOnly": "pnpm build",
+    "test": "tsx --test",
+    "typecheck": "tsc --noEmit"
+  },
+  "type": "module"
+}