@jahands/dagger-helpers 0.7.3 → 0.7.5

package/src/index.ts

@@ -0,0 +1,11 @@
+export { constants } from './constants.js'
+
+export { ParamsToEnv, envStorage } from './env.js'
+export type { EnvContext } from './env.js'
+
+export { shell } from './shell.js'
+
+export { getModulePath } from './path.js'
+
+export { convertToCamel } from './convert/snake-to-camel.js'
+export { convertToSnake } from './convert/camel-to-snake.js'

package/src/path.spec.ts

@@ -0,0 +1,34 @@
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { getModulePath, getRepoRoot } from './path.js'
+
+const testDir = `${__dirname}/test`
+const fixtures = `${testDir}/fixtures`
+const repoDir = `${fixtures}/repo`
+const moduleDir = `${repoDir}/path/to/module`
+const moduleSrcDir = `${moduleDir}/.dagger/src`
+
+afterEach(() => {
+	process.chdir(path.resolve(__dirname, '..'))
+})
+
+/** convert from absolute path to relative of dagger-helpers package */
+function trimPath(p: string): string {
+	return p.replace(testDir, '')
+}
+
+describe('getRepoRoot()', () => {
+	it('returns the directory of the first pnpm-lock.yaml it finds', () => {
+		process.chdir(moduleSrcDir)
+		expect(trimPath(getRepoRoot())).toBe(`/fixtures/repo`)
+	})
+})
+
+describe('getModulePath()', () => {
+	it('should return path to the dagger module relative to repo root', () => {
+		process.chdir(moduleSrcDir)
+		const p = getModulePath()
+		expect(p).toBe('path/to/module')
+	})
+})

package/src/path.ts

@@ -0,0 +1,39 @@
+import path from 'node:path'
+import { up } from 'empathic/find'
+
+export function getRepoRoot(cwd?: string): string {
+	cwd = cwd ?? process.cwd()
+
+	const lockfile = up('pnpm-lock.yaml', { cwd })
+	if (!lockfile) {
+		throw new Error('could not determine repo root path: unable to find pnpm-lock.yaml')
+	}
+
+	return path.dirname(lockfile)
+}
+
+/**
+ * Get the path to the dagger module.
+ *
+ * Requires `pnpm-lock.yaml` to exist in the repo root.
+ *
+ * @param cwd - The current working directory. **Default:** `process.cwd()`
+ *
+ * @returns The path to the dagger module relative to the repo root
+ */
+export function getModulePath(cwd?: string): string {
+	cwd = cwd ?? process.cwd()
+
+	const lockfile = up('pnpm-lock.yaml', { cwd })
+	if (!lockfile) {
+		throw new Error('could not determine repo root path: unable to find pnpm-lock.yaml')
+	}
+	const repoRoot = path.dirname(lockfile)
+
+	const daggerJson = up('dagger.json', { cwd, last: repoRoot })
+	if (!daggerJson) {
+		throw new Error('could not determine dagger.json path: unable to find dagger.json')
+	}
+
+	return path.relative(repoRoot, path.dirname(daggerJson))
+}

package/src/shell.ts

@@ -0,0 +1,58 @@
+import { match } from 'ts-pattern'
+
+/**
+ * Shell options for a given command
+ */
+export type ShellOptions = {
+	/**
+	 * Prefix to add to all commands.
+	 *
+	 * @default
+	 * ```sh
+	 * # bash, zsh
+	 * set -euo pipefail;
+	 * # sh
+	 * set -eu;
+	 * ```
+	 */
+	prefix?: string
+}
+
+/**
+ * Create a new shell helper with the given shell type
+ *
+ * @param shellName - The name of the shell to use
+ *
+ * @example
+ *
+ * ```ts
+ * const sh = shell('bash')
+ *
+ * const con = dag.container()
+ *   .withExec(sh('echo hello world!'))
+ * ```
+ */
+export function shell(shellName: 'sh' | 'bash' | 'zsh') {
+	return (input: string | string[], options?: ShellOptions): string[] => {
+		const inputAr = Array.isArray(input) ? input : [input]
+		const trimmedInput = inputAr.map((i) =>
+			i
+				.trim()
+				.split('\n')
+				.map((l) => l.trim())
+				.join('\n')
+		)
+
+		let prefix = match(shellName)
+			.with('bash', 'zsh', () => options?.prefix || 'set -euo pipefail')
+			.with('sh', () => options?.prefix || 'set -eu')
+			.exhaustive()
+			.trim()
+
+		if (!prefix.endsWith(';')) {
+			prefix += ';'
+		}
+
+		return [shellName, '-c', `${prefix} ${trimmedInput}`]
+	}
+}

package/src/test/fixtures/repo/path/to/module/.dagger/src/index.ts

@@ -0,0 +1 @@
+// fake dagger module