@aopslabs/aops 0.2.0

package/dist/utils/operator-runtime.js

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+function normalizeNonEmpty(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function compactProjectBinding(project) {
+    const binding = {
+        name: project.name,
+        projectId: project.projectId,
+    };
+    if (project.slug)
+        binding.slug = project.slug;
+    return binding;
+}
+function normalizeProjectRecord(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const record = raw;
+    const name = normalizeNonEmpty(record.name);
+    const projectId = normalizeNonEmpty(record.projectId);
+    const scopeId = normalizeNonEmpty(record.scopeId);
+    const slug = normalizeNonEmpty(record.slug);
+    if (!name || !projectId)
+        return null;
+    return compactProjectBinding({
+        name,
+        projectId,
+        scopeId: scopeId ?? projectId,
+        slug,
+    });
+}
+function normalizeProjectName(value) {
+    return normalizeNonEmpty(value)?.toLowerCase();
+}
+function normalizeOperatorDefaults(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const record = raw;
+    const defaults = {
+        apiBaseUrl: normalizeNonEmpty(record.apiBaseUrl),
+        tenantId: normalizeNonEmpty(record.tenantId),
+        scopeId: normalizeNonEmpty(record.scopeId),
+        locale: normalizeNonEmpty(record.locale),
+        fallbackLocale: normalizeNonEmpty(record.fallbackLocale),
+    };
+    return Object.values(defaults).some(Boolean) ? defaults : undefined;
+}
+function resolveActiveProjectName(projects, activeProjectName) {
+    const normalizedActiveProjectName = normalizeProjectName(activeProjectName);
+    if (normalizedActiveProjectName) {
+        const activeProject = projects.find((project) => normalizeProjectName(project.name) === normalizedActiveProjectName);
+        if (activeProject)
+            return activeProject.name;
+    }
+    return projects[0]?.name;
+}
+export function findWorkspaceRoot(startDir = process.cwd()) {
+    const resolvedStart = path.resolve(startDir);
+    let current = resolvedStart;
+    while (true) {
+        const packageJson = path.join(current, 'package.json');
+        if (existsSync(packageJson))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return resolvedStart;
+        current = parent;
+    }
+}
+export function resolveRepoConfigPath(rootDir) {
+    return path.join(rootDir, '.aops', 'aops.config.json');
+}
+export function parseJsonInput(input, label) {
+    if (input === undefined || input === null)
+        return undefined;
+    if (typeof input !== 'string')
+        return input;
+    const trimmed = input.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith('@')) {
+        const filePath = trimmed.slice(1).trim();
+        if (!filePath)
+            throw new Error(`Invalid JSON for ${label}.`);
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    return JSON.parse(trimmed);
+}
+export function buildDomainApiPath(domain, routePath) {
+    const normalizedDomain = domain.trim().toLowerCase().replace(/^\/+|\/+$/g, '');
+    const normalizedPath = (routePath ?? '').trim().replace(/^\/+|\/+$/g, '');
+    return normalizedPath.length > 0 ? `/api/${normalizedDomain}/${normalizedPath}` : `/api/${normalizedDomain}`;
+}
+export function appendQueryToPath(pathname, query) {
+    if (!query || typeof query !== 'object' || Array.isArray(query))
+        return pathname;
+    const params = new URLSearchParams();
+    for (const [keyRaw, value] of Object.entries(query)) {
+        const key = keyRaw.trim();
+        if (!key || value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                params.append(key, String(item));
+            continue;
+        }
+        if (typeof value === 'object') {
+            params.append(key, JSON.stringify(value));
+            continue;
+        }
+        params.append(key, String(value));
+    }
+    const queryString = params.toString();
+    return queryString ? `${pathname}?${queryString}` : pathname;
+}
+export function buildOperatorHeaders(context = {}) {
+    const headers = {};
+    const tenantId = normalizeNonEmpty(context.tenantId);
+    const scopeId = normalizeNonEmpty(context.scopeId);
+    const locale = normalizeNonEmpty(context.locale);
+    const fallbackLocale = normalizeNonEmpty(context.fallbackLocale);
+    const projectId = normalizeNonEmpty(context.projectId);
+    const projectName = normalizeNonEmpty(context.projectName);
+    if (tenantId)
+        headers['x-tenant-id'] = tenantId;
+    if (scopeId)
+        headers['x-scope-id'] = scopeId;
+    if (locale)
+        headers['x-locale'] = locale;
+    if (fallbackLocale)
+        headers['x-fallback-locale'] = fallbackLocale;
+    if (projectId)
+        headers['x-project-id'] = projectId;
+    else if (projectName)
+        headers['x-project-name'] = projectName;
+    if (context.scopeResolution)
+        headers['x-scope-resolution'] = context.scopeResolution;
+    return headers;
+}
+export function buildHostedToolInvokeRequestBody(options) {
+    const requestBody = {};
+    const sourceId = normalizeNonEmpty(options.sourceId)?.toLowerCase();
+    const idempotencyKey = normalizeNonEmpty(options.idempotencyKey);
+    if (sourceId)
+        requestBody.sourceId = sourceId;
+    if (options.input !== undefined)
+        requestBody.input = options.input;
+    if (options.preview === true)
+        requestBody.preview = true;
+    if (options.apply === true)
+        requestBody.apply = true;
+    if (options.confirm === true)
+        requestBody.confirm = true;
+    if (idempotencyKey)
+        requestBody.idempotencyKey = idempotencyKey;
+    return requestBody;
+}
+export function buildOperatorRepoConfig(params) {
+    return {
+        schemaVersion: 2,
+        repo: { name: params.repoName },
+        activeProjectName: params.projectName,
+        projects: [
+            compactProjectBinding({
+                name: params.projectName,
+                projectId: params.projectId,
+                scopeId: params.scopeId ?? params.projectId,
+                slug: params.projectSlug,
+            }),
+        ],
+        ...(params.operatorDefaults && Object.values(params.operatorDefaults).some(Boolean)
+            ? { operatorDefaults: params.operatorDefaults }
+            : {}),
+    };
+}
+export function normalizeOperatorRepoConfig(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const typed = raw;
+    const repoName = normalizeNonEmpty(typed.repo?.name);
+    const rawProjects = Array.isArray(typed.projects) ? typed.projects : [];
+    const projects = rawProjects
+        .map((project) => normalizeProjectRecord(project))
+        .filter((project) => Boolean(project));
+    const activeProjectName = resolveActiveProjectName(projects, typed.activeProjectName);
+    const operatorDefaults = normalizeOperatorDefaults(typed.operatorDefaults);
+    if (!repoName || !activeProjectName || projects.length === 0)
+        return null;
+    return {
+        schemaVersion: 2,
+        repo: { name: repoName },
+        activeProjectName,
+        projects,
+        ...(operatorDefaults ? { operatorDefaults } : {}),
+    };
+}

package/dist/utils/password-crypto.js

@@ -0,0 +1,39 @@
+import crypto from 'node:crypto';
+async function deriveKey(password, salt) {
+    return await new Promise((resolve, reject) => {
+        crypto.scrypt(password, salt, 32, (error, key) => {
+            if (error)
+                reject(error);
+            else
+                resolve(key);
+        });
+    });
+}
+export async function encryptWithPassword(value, password, salt = crypto.randomBytes(16)) {
+    const key = await deriveKey(password, salt);
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const data = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]);
+    return {
+        key,
+        payload: {
+            v: 1,
+            kdf: 'scrypt',
+            salt: salt.toString('base64'),
+            iv: iv.toString('base64'),
+            tag: cipher.getAuthTag().toString('base64'),
+            data: data.toString('base64'),
+        },
+    };
+}
+export async function decryptWithPassword(payload, password) {
+    if (payload.v !== 1 || payload.kdf !== 'scrypt')
+        throw new Error('aops_encrypted_payload_invalid');
+    const key = await deriveKey(password, Buffer.from(payload.salt, 'base64'));
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(payload.iv, 'base64'));
+    decipher.setAuthTag(Buffer.from(payload.tag, 'base64'));
+    return Buffer.concat([
+        decipher.update(Buffer.from(payload.data, 'base64')),
+        decipher.final(),
+    ]).toString('utf8');
+}