@nocobase/cli 2.1.0-alpha.4 → 2.1.0-alpha.40

package/dist/lib/naming.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+export function toKebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}
+export function splitPathAction(pathTemplate) {
+    const normalizedPath = pathTemplate.replace(/^\/+/, '');
+    const separatorIndex = normalizedPath.lastIndexOf(':');
+    if (separatorIndex === -1) {
+        return {
+            resourcePath: normalizedPath,
+            action: 'call',
+        };
+    }
+    return {
+        resourcePath: normalizedPath.slice(0, separatorIndex),
+        action: normalizedPath.slice(separatorIndex + 1),
+    };
+}
+export function toLogicalResourceName(pathTemplate) {
+    const { resourcePath } = splitPathAction(pathTemplate);
+    return resourcePath
+        .split('/')
+        .filter(Boolean)
+        .filter((segment) => !segment.startsWith('{'))
+        .map((segment) => toKebabCase(segment))
+        .join('.');
+}
+export function toLogicalActionName(pathTemplate) {
+    return toKebabCase(splitPathAction(pathTemplate).action);
+}
+export function toResourceSegments(pathTemplate, options) {
+    const { resourcePath, action } = splitPathAction(pathTemplate);
+    const pathSegments = resourcePath
+        .split('/')
+        .filter(Boolean)
+        .flatMap((segment) => {
+        if (!segment.startsWith('{')) {
+            return [toKebabCase(segment)];
+        }
+        if (!options?.includeParams) {
+            return [];
+        }
+        return [`by-${toKebabCase(segment.slice(1, -1))}`];
+    });
+    return [...pathSegments, toKebabCase(action)].filter(Boolean);
+}
+export function toCommandSegments(moduleName, pathTemplate, options) {
+    const resourceSegments = toResourceSegments(pathTemplate, options);
+    const segments = [options?.omitModule ? '' : toKebabCase(moduleName), ...resourceSegments].filter(Boolean);
+    return segments.length ? segments : [toKebabCase(moduleName), 'call'];
+}
+export function toClassName(segments) {
+    return segments
+        .map((segment) => segment.replace(/(^\w|-\w)/g, (token) => token.replace('-', '').toUpperCase()))
+        .join('');
+}
+export function toOutputFile(outputRoot, segments) {
+    const folder = path.join(outputRoot, ...segments.slice(0, -1));
+    const filePath = path.join(folder, `${segments.at(-1)}.ts`);
+    return filePath;
+}
+export function toImportPath(fromFile, targetFile) {
+    const relative = path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, '/');
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}

package/dist/lib/object-utils.js

@@ -0,0 +1,76 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export function pickKeys(object, keys) {
+    const picked = {};
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            const typedKey = key;
+            picked[typedKey] = object[typedKey];
+        }
+    }
+    return picked;
+}
+export function omitKeys(object, keys) {
+    const omittedKeys = new Set(keys);
+    const result = {};
+    for (const key of Object.keys(object)) {
+        if (!omittedKeys.has(key)) {
+            const typedKey = key;
+            result[typedKey] = object[typedKey];
+        }
+    }
+    return result;
+}
+export function upperFirst(value) {
+    if (!value) {
+        return value;
+    }
+    return value[0].toUpperCase() + value.slice(1);
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (left == null || right == null) {
+        return false;
+    }
+    if (typeof left !== typeof right) {
+        return false;
+    }
+    if (typeof left !== 'object') {
+        return false;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (!deepEqual(left[index], right[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const leftObject = left;
+    const rightObject = right;
+    const leftKeys = Object.keys(leftObject);
+    const rightKeys = Object.keys(rightObject);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(rightObject, key)) {
+            return false;
+        }
+        if (!deepEqual(leftObject[key], rightObject[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/lib/openapi.js

@@ -0,0 +1,62 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+function resolveLocalRef(document, ref) {
+    if (!ref.startsWith('#/')) {
+        return undefined;
+    }
+    return ref
+        .slice(2)
+        .split('/')
+        .reduce((current, segment) => current?.[segment], document);
+}
+function dereferenceNode(node, document, seen = new Set()) {
+    if (Array.isArray(node)) {
+        return node.map((item) => dereferenceNode(item, document, seen));
+    }
+    if (!node || typeof node !== 'object') {
+        return node;
+    }
+    const ref = node.$ref;
+    if (typeof ref === 'string') {
+        if (seen.has(ref)) {
+            return {};
+        }
+        const resolved = resolveLocalRef(document, ref);
+        if (!resolved) {
+            return node;
+        }
+        return dereferenceNode(resolved, document, new Set([...seen, ref]));
+    }
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, dereferenceNode(value, document, seen)]));
+}
+export function collectOperations(document) {
+    const operations = [];
+    for (const [pathTemplate, pathItem] of Object.entries(document.paths ?? {})) {
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem?.[method];
+            if (!operation || '$ref' in operation) {
+                continue;
+            }
+            const parameters = [...(pathItem.parameters ?? []), ...(operation.parameters ?? [])]
+                .map((parameter) => dereferenceNode(parameter, document))
+                .filter((parameter) => Boolean(parameter && !('$ref' in parameter)));
+            operations.push({
+                method,
+                pathTemplate,
+                operation: {
+                    ...operation,
+                    parameters,
+                    requestBody: operation.requestBody ? dereferenceNode(operation.requestBody, document) : undefined,
+                },
+            });
+        }
+    }
+    return operations;
+}

package/dist/lib/plugin-storage.js

@@ -0,0 +1,64 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import path from 'node:path';
+import { access, lstat, readlink, rm } from 'node:fs/promises';
+async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolvePluginStoragePath(storagePath) {
+    const root = String(storagePath ?? process.env.STORAGE_PATH ?? '').trim();
+    if (root) {
+        return path.join(path.isAbsolute(root) ? root : path.resolve(process.cwd(), root), 'plugins');
+    }
+    const configured = String(process.env.PLUGIN_STORAGE_PATH ?? '').trim();
+    if (configured) {
+        return path.isAbsolute(configured) ? configured : path.resolve(process.cwd(), configured);
+    }
+    return path.resolve(process.cwd(), 'storage', 'plugins');
+}
+export async function removeStoragePluginSymlink(pluginName, storagePath, nodeModulesPath = String(process.env.NODE_MODULES_PATH ?? '').trim()) {
+    if (!nodeModulesPath) {
+        return false;
+    }
+    const storagePluginsPath = resolvePluginStoragePath(storagePath);
+    const targetPath = path.resolve(storagePluginsPath, pluginName);
+    const linkPath = path.resolve(nodeModulesPath, pluginName);
+    if (!(await pathExists(linkPath))) {
+        return false;
+    }
+    let statResult;
+    try {
+        statResult = await lstat(linkPath);
+    }
+    catch {
+        return false;
+    }
+    if (!statResult.isSymbolicLink()) {
+        return false;
+    }
+    let resolvedLinkTarget = '';
+    try {
+        const linkTarget = await readlink(linkPath);
+        resolvedLinkTarget = path.resolve(path.dirname(linkPath), linkTarget);
+    }
+    catch {
+        return false;
+    }
+    if (resolvedLinkTarget !== targetPath) {
+        return false;
+    }
+    await rm(linkPath, { recursive: true, force: true });
+    return true;
+}

package/dist/lib/post-processors.js

@@ -0,0 +1,23 @@
+function buildKey(resource, action) {
+    return `${resource}:${action}`;
+}
+class PostProcessorRegistry {
+    processors = new Map();
+    register(resource, action, processor) {
+        this.processors.set(buildKey(resource, action), processor);
+    }
+    resolve(resource, action) {
+        if (!resource || !action) {
+            return undefined;
+        }
+        return this.processors.get(buildKey(resource, action));
+    }
+}
+export const postProcessorRegistry = new PostProcessorRegistry();
+export async function applyPostProcessor(result, context) {
+    const processor = postProcessorRegistry.resolve(context.operation.logicalResourceName, context.operation.actionName);
+    if (!processor) {
+        return result;
+    }
+    return processor(result, context);
+}

package/dist/lib/prompt-catalog-core.js

@@ -0,0 +1,185 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { createCliTranslate, resolveCliLocale, resolveLocalizedText, } from "./cli-locale.js";
+export function selectOptionValues(options) {
+    return options.map((o) => (typeof o === 'string' ? o : o.value));
+}
+export function resolvePromptText(text, locale, fallback = '') {
+    return resolveLocalizedText(text, { locale, fallback });
+}
+export function enabledSelectOptionValues(options) {
+    return options
+        .filter((o) => typeof o === 'string' || o.disabled !== true)
+        .map((o) => (typeof o === 'string' ? o : o.value));
+}
+export function createPromptCatalogHooks(locale, overrides, defaults) {
+    return {
+        onCancel: overrides?.onCancel
+            ?? defaults?.onCancel
+            ?? (() => {
+                throw new Error(createCliTranslate(locale)('promptCatalog.common.cancelled'));
+            }),
+        onMissingNonInteractive: overrides?.onMissingNonInteractive
+            ?? defaults?.onMissingNonInteractive
+            ?? ((message) => {
+                throw new Error(message);
+            }),
+    };
+}
+export function hasIvKey(iv, key) {
+    return (Object.prototype.hasOwnProperty.call(iv, key) && iv[key] !== undefined && iv[key] !== null);
+}
+export function resolveTextInitial(def, valuesSoFar) {
+    const iv = def.initialValue;
+    if (typeof iv === 'function') {
+        return iv(valuesSoFar);
+    }
+    return iv;
+}
+export function mergedText(key, def, iv, useYesInitial, valuesSoFar = {}) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key]);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return resolveTextInitial(def, valuesSoFar) ?? '';
+}
+export function mergedBoolean(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        return Boolean(iv[key]);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue ?? true;
+}
+export function mergedSelect(key, def, iv, useYesInitial) {
+    const enabledValueList = enabledSelectOptionValues(def.options);
+    if (hasIvKey(iv, key)) {
+        const s = String(iv[key]);
+        if (enabledValueList.includes(s)) {
+            return s;
+        }
+        return undefined;
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined && enabledValueList.includes(def.yesInitialValue)) {
+        return def.yesInitialValue;
+    }
+    const d = def.initialValue;
+    if (d !== undefined && enabledValueList.includes(d)) {
+        return d;
+    }
+    return enabledValueList[0];
+}
+export function mergedInteger(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        const v = iv[key];
+        return typeof v === 'number' ? v : Number.parseInt(String(v), 10);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue;
+}
+export function mergedPassword(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key] ?? '');
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue;
+}
+export function isBlankText(value) {
+    return value.trim() === '';
+}
+export async function runPromptFieldValidate(def, value, values) {
+    if (def.type === 'intro' || def.type === 'outro' || def.type === 'run') {
+        return undefined;
+    }
+    if (!('validate' in def) || def.validate === undefined) {
+        return undefined;
+    }
+    const r = await def.validate(value, values);
+    if (r == null || r === '') {
+        return undefined;
+    }
+    return String(r);
+}
+export function isPromptBlockSkipped(def, values) {
+    if (def.type === 'run') {
+        return def.when !== undefined && !def.when(values);
+    }
+    return def.hidden !== undefined && def.hidden(values);
+}
+export function tryApplyPreset(key, def, preset, out, hooks, locale) {
+    const t = createCliTranslate(locale);
+    if (!hasIvKey(preset, key)) {
+        return false;
+    }
+    const raw = preset[key];
+    switch (def.type) {
+        case 'intro':
+        case 'outro':
+        case 'run':
+            return false;
+        case 'text': {
+            const s = String(raw ?? '');
+            if (def.required && isBlankText(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'boolean': {
+            out[key] = Boolean(raw);
+            return true;
+        }
+        case 'select': {
+            const valueList = selectOptionValues(def.options);
+            const s = String(raw ?? '');
+            if (!valueList.includes(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidSelect', { key, value: s, options: valueList.join(', ') }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'password': {
+            const s = String(raw ?? '');
+            if (def.required && isBlankText(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'integer': {
+            if (typeof raw === 'number' && Number.isFinite(raw)) {
+                out[key] = raw;
+                return true;
+            }
+            const s = String(raw ?? '').trim();
+            if (s === '') {
+                if (def.required) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+                }
+                out[key] = def.initialValue ?? 0;
+                return true;
+            }
+            if (!/^-?\\d+$/.test(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidInteger', { key }));
+            }
+            out[key] = Number.parseInt(s, 10);
+            return true;
+        }
+    }
+}
+export function resolvePromptCatalogLocale(locale) {
+    return resolveCliLocale(locale);
+}