@nocobase/cli 2.2.0-alpha.1 → 2.2.0-alpha.10

package/dist/lib/auth-store.js

@@ -11,7 +11,9 @@ import path from 'node:path';
 import { resolveAppPublicPath } from './app-public-path.js';
 import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
 import { normalizeCliLocale } from './cli-locale.js';
+import { normalizeEnvProxyConfig, normalizeEnvProxyProviderConfig, } from './env-proxy-config.js';
 import { inferConfiguredAppPathFromLegacyConfig, resolveConfiguredAppPath, resolveConfiguredSourcePath, resolveConfiguredStoragePath, } from './env-paths.js';
+import { ENV_CONFIG_SCHEMA_VERSION, normalizeEnvConfigSchemaVersion } from './env-config.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
@@ -76,14 +78,18 @@ function normalizeEnvConfigEntry(entry) {
     if (!entry) {
         return entry;
     }
-    const { kind: _kind, apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, ...rest } = entry;
+    const { kind: _kind, apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, schemaVersion: _schemaVersion, ...rest } = entry;
     const normalizedKind = resolveEnvKind(entry);
     const apiBaseUrl = readEnvApiBaseUrl(entry);
+    const schemaVersion = normalizeEnvConfigSchemaVersion(entry.schemaVersion);
+    const proxy = normalizeEnvProxyConfig(entry.proxy);
     return {
         ...rest,
+        ...(schemaVersion ? { schemaVersion } : {}),
         ...(normalizedKind ? { kind: normalizedKind } : {}),
         ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
         ...(normalizeOptionalString(entry.appPublicPath) ? { appPublicPath: resolveAppPublicPath(entry.appPublicPath) } : {}),
+        ...(proxy ? { proxy } : {}),
     };
 }
 function normalizeAuthConfig(config) {
@@ -91,51 +97,68 @@ function normalizeAuthConfig(config) {
     const locale = normalizeOptionalCliLocale(settings.locale);
     const defaultUiHost = normalizeOptionalString(settings.init?.defaultUiHost);
     const defaultApiHost = normalizeOptionalString(settings.init?.defaultApiHost);
+    const defaultPortalTemplate = normalizeOptionalString(settings.init?.defaultPortalTemplate);
     const updatePolicy = normalizeOptionalCliUpdatePolicy(settings.update?.policy);
     const logRetentionDays = typeof settings.log?.retentionDays === 'number' && Number.isInteger(settings.log.retentionDays)
         ? settings.log.retentionDays
         : undefined;
     const logEnabled = typeof settings.log?.enabled === 'boolean' ? settings.log.enabled : undefined;
+    const hasBinSettings = settings.bin?.docker ||
+        settings.bin?.caddy ||
+        settings.bin?.git ||
+        settings.bin?.nginx ||
+        settings.bin?.pnpm ||
+        settings.bin?.yarn;
+    const hasProxySettings = settings.proxy?.nbCliRoot ||
+        settings.proxy?.caddyDriver ||
+        settings.proxy?.nginxDriver ||
+        settings.proxy?.upstreamHost ||
+        settings.proxy?.host;
     return {
         name: config.name || config.dockerResourcePrefix,
         settings: {
             ...(locale ? { locale } : {}),
-            ...(defaultUiHost || defaultApiHost
+            ...(defaultUiHost || defaultApiHost || defaultPortalTemplate
                 ? {
                     init: {
                         ...(defaultUiHost ? { defaultUiHost } : {}),
                         ...(defaultApiHost ? { defaultApiHost } : {}),
+                        ...(defaultPortalTemplate ? { defaultPortalTemplate } : {}),
                     },
                 }
                 : {}),
             ...(updatePolicy ? { update: { policy: updatePolicy } } : {}),
             ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
             ...(settings.docker?.network || settings.docker?.containerPrefix
+                || settings.docker?.nbImageRegistry || settings.docker?.nbImageVariant
                 ? {
                     docker: {
                         ...(settings.docker?.network ? { network: normalizeOptionalString(settings.docker.network) } : {}),
                         ...(settings.docker?.containerPrefix
                             ? { containerPrefix: normalizeOptionalString(settings.docker.containerPrefix) }
                             : {}),
+                        ...(settings.docker?.nbImageRegistry
+                            ? { nbImageRegistry: normalizeOptionalString(settings.docker.nbImageRegistry) }
+                            : {}),
+                        ...(settings.docker?.nbImageVariant
+                            ? { nbImageVariant: normalizeOptionalString(settings.docker.nbImageVariant) }
+                            : {}),
                     },
                 }
                 : {}),
-            ...(settings.bin?.docker || settings.bin?.caddy || settings.bin?.git || settings.bin?.nginx || settings.bin?.yarn
+            ...(hasBinSettings
                 ? {
                     bin: {
                         ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
                         ...(settings.bin?.caddy ? { caddy: normalizeOptionalString(settings.bin.caddy) } : {}),
                         ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
                         ...(settings.bin?.nginx ? { nginx: normalizeOptionalString(settings.bin.nginx) } : {}),
+                        ...(settings.bin?.pnpm ? { pnpm: normalizeOptionalString(settings.bin.pnpm) } : {}),
                         ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
                     },
                 }
                 : {}),
-            ...(settings.proxy?.nbCliRoot ||
-                settings.proxy?.caddyDriver ||
-                settings.proxy?.nginxDriver ||
-                settings.proxy?.upstreamHost ||
-                settings.proxy?.host
+            ...(hasProxySettings
                 ? {
                     proxy: {
                         ...(settings.proxy?.nbCliRoot ? { nbCliRoot: normalizeOptionalString(settings.proxy.nbCliRoot) } : {}),
@@ -366,7 +389,13 @@ function areAuthConfigsEquivalent(left, right) {
 async function writeEnv(envName, updater, options = {}) {
     const config = await loadExactAuthConfig(options);
     const previous = config.envs[envName];
-    config.envs[envName] = updater(previous);
+    const next = updater(previous);
+    config.envs[envName] = {
+        ...next,
+        schemaVersion: normalizeEnvConfigSchemaVersion(next.schemaVersion) ??
+            normalizeEnvConfigSchemaVersion(previous?.schemaVersion) ??
+            ENV_CONFIG_SCHEMA_VERSION,
+    };
     await saveAuthConfig(config, options);
 }
 function normalizeConfiguredAuthType(value) {
@@ -377,18 +406,19 @@ export function resolveConfiguredAuthType(config) {
 }
 export async function upsertEnv(envName, config, options = {}) {
     await writeEnv(envName, (previous) => {
-        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, ...rest } = config;
+        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, schemaVersion, ...rest } = config;
         const nextApiBaseUrl = readEnvApiBaseUrl(config);
         const previousApiBaseUrl = readEnvApiBaseUrl(previous);
         const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
         const previousAuthType = resolveConfiguredAuthType(previous);
         const requestedAuthType = normalizeConfiguredAuthType(authType);
-        const nextAuthType = requestedAuthType ?? (accessToken ? 'token' : previousAuthType);
+        const nextAccessToken = normalizeOptionalString(accessToken);
+        const nextAuthType = requestedAuthType ?? (nextAccessToken ? 'token' : previousAuthType);
         const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) ?? previous?.authUsername : undefined;
-        const nextAuth = accessToken
+        const nextAuth = nextAccessToken
             ? {
                 type: 'token',
-                accessToken,
+                accessToken: nextAccessToken,
             }
             : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
                 ? previous.auth
@@ -396,6 +426,9 @@ export async function upsertEnv(envName, config, options = {}) {
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
         const authTypeChanged = previousAuthType !== nextAuthType;
         const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
+        const nextSchemaVersion = normalizeEnvConfigSchemaVersion(schemaVersion) ??
+            normalizeEnvConfigSchemaVersion(previous?.schemaVersion) ??
+            ENV_CONFIG_SCHEMA_VERSION;
         return {
             ...previous,
             apiBaseUrl: nextApiBaseUrl,
@@ -403,6 +436,7 @@ export async function upsertEnv(envName, config, options = {}) {
             authUsername: nextAuthUsername,
             auth: nextAuth,
             ...rest,
+            schemaVersion: nextSchemaVersion,
             runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
         };
     }, options);
@@ -487,6 +521,64 @@ export async function setEnvRuntime(envName, runtime, options = {}) {
     };
     await saveAuthConfig(config, options);
 }
+export function resolveEnvProxyEntry(config, provider) {
+    const proxy = normalizeEnvProxyConfig(config?.proxy);
+    const resolved = {
+        ...(proxy?.host ? { host: proxy.host } : {}),
+        ...(proxy?.port !== undefined ? { port: proxy.port } : {}),
+        ...((provider === 'nginx' ? proxy?.nginx : proxy?.caddy) ?? {}),
+    };
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+export async function setEnvProxyEntry(envName, provider, entry, options = {}) {
+    await writeEnv(envName, (previous) => {
+        const currentProxy = normalizeEnvProxyConfig(previous?.proxy) ?? {};
+        const nextEntry = normalizeEnvProxyProviderConfig(entry);
+        const nextProxy = { ...currentProxy };
+        if (nextEntry && 'host' in nextEntry) {
+            const host = normalizeOptionalString(nextEntry.host);
+            if (host) {
+                nextProxy.host = host;
+            }
+            else {
+                delete nextProxy.host;
+            }
+        }
+        if (nextEntry && 'port' in nextEntry) {
+            const portValue = nextEntry.port;
+            const port = typeof portValue === 'number' && Number.isInteger(portValue) && portValue >= 1 && portValue <= 65535
+                ? portValue
+                : undefined;
+            if (port !== undefined) {
+                nextProxy.port = port;
+            }
+            else {
+                delete nextProxy.port;
+            }
+        }
+        const providerConfig = nextEntry && Object.keys(nextEntry).some((key) => key !== 'host' && key !== 'port')
+            ? Object.fromEntries(Object.entries(nextEntry).filter(([key]) => key !== 'host' && key !== 'port'))
+            : undefined;
+        if (provider === 'nginx') {
+            if (providerConfig && Object.keys(providerConfig).length > 0) {
+                nextProxy.nginx = providerConfig;
+            }
+            else {
+                delete nextProxy.nginx;
+            }
+        }
+        else if (providerConfig && Object.keys(providerConfig).length > 0) {
+            nextProxy.caddy = providerConfig;
+        }
+        else {
+            delete nextProxy.caddy;
+        }
+        return {
+            ...previous,
+            proxy: nextProxy,
+        };
+    }, options);
+}
 export async function clearEnvRootSetup(envName, options = {}) {
     const config = await loadExactAuthConfig(options);
     const current = config.envs[envName];

package/dist/lib/cli-config.js

@@ -9,6 +9,7 @@
 import { loadExactAuthConfig, saveAuthConfig } from './auth-store.js';
 import { resolveCliHomeRoot, resolveDefaultConfigScope } from './cli-home.js';
 import { CLI_LOCALE_FLAG_OPTIONS, normalizeCliLocale, resolveCliLocale } from './cli-locale.js';
+import { DEFAULT_NB_IMAGE_REGISTRY, DEFAULT_NB_IMAGE_VARIANT, NB_IMAGE_REGISTRY_OPTIONS, NB_IMAGE_VARIANT_OPTIONS, normalizeNbImageRegistry, normalizeNbImageVariant, } from './docker-image.js';
 export const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
 export const DEFAULT_DOCKER_NETWORK = 'nocobase';
 export const DEFAULT_DOCKER_CONTAINER_PREFIX = 'nb';
@@ -16,6 +17,7 @@ export const DEFAULT_DOCKER_BIN = 'docker';
 export const DEFAULT_CADDY_BIN = 'caddy';
 export const DEFAULT_GIT_BIN = 'git';
 export const DEFAULT_NGINX_BIN = 'nginx';
+export const DEFAULT_PNPM_BIN = 'pnpm';
 export const PROXY_PROVIDER_OPTIONS = ['nginx', 'caddy'];
 export const DEFAULT_PROXY_PROVIDER = 'nginx';
 export const NGINX_PROXY_DRIVER_OPTIONS = ['local', 'docker'];
@@ -32,14 +34,18 @@ export const SUPPORTED_CLI_CONFIG_KEYS = [
     'locale',
     'default-ui-host',
     'default-api-host',
+    'default-portal-template',
     'update.policy',
     'license.pkg-url',
     'docker.network',
     'docker.container-prefix',
+    'nb-image-registry',
+    'nb-image-variant',
     'bin.docker',
     'bin.caddy',
     'bin.git',
     'bin.nginx',
+    'bin.pnpm',
     'proxy.nb-cli-root',
     'proxy.caddy-driver',
     'proxy.nginx-driver',
@@ -115,7 +121,10 @@ function pruneSettings(config) {
         delete config.settings.locale;
     }
     const init = config.settings?.init;
-    if (init && !trimValue(init.defaultUiHost) && !trimValue(init.defaultApiHost)) {
+    if (init &&
+        !trimValue(init.defaultUiHost) &&
+        !trimValue(init.defaultApiHost) &&
+        !trimValue(init.defaultPortalTemplate)) {
         delete config.settings?.init;
     }
     const update = config.settings?.update;
@@ -127,7 +136,11 @@ function pruneSettings(config) {
         delete config.settings?.license;
     }
     const docker = config.settings?.docker;
-    if (docker && !trimValue(docker.network) && !trimValue(docker.containerPrefix)) {
+    if (docker &&
+        !trimValue(docker.network) &&
+        !trimValue(docker.containerPrefix) &&
+        !trimValue(docker.nbImageRegistry) &&
+        !trimValue(docker.nbImageVariant)) {
         delete config.settings?.docker;
     }
     const bin = config.settings?.bin;
@@ -136,6 +149,7 @@ function pruneSettings(config) {
         !trimValue(bin.caddy) &&
         !trimValue(bin.git) &&
         !trimValue(bin.nginx) &&
+        !trimValue(bin.pnpm) &&
         !trimValue(bin.yarn)) {
         delete config.settings?.bin;
     }
@@ -171,6 +185,8 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.init?.defaultUiHost);
         case 'default-api-host':
             return trimValue(config.settings?.init?.defaultApiHost);
+        case 'default-portal-template':
+            return trimValue(config.settings?.init?.defaultPortalTemplate);
         case 'update.policy':
             return normalizeCliUpdatePolicy(config.settings?.update?.policy);
         case 'license.pkg-url':
@@ -179,6 +195,10 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.docker?.network);
         case 'docker.container-prefix':
             return trimValue(config.settings?.docker?.containerPrefix);
+        case 'nb-image-registry':
+            return normalizeNbImageRegistry(config.settings?.docker?.nbImageRegistry);
+        case 'nb-image-variant':
+            return normalizeNbImageVariant(config.settings?.docker?.nbImageVariant);
         case 'bin.docker':
             return trimValue(config.settings?.bin?.docker);
         case 'bin.caddy':
@@ -187,6 +207,8 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.bin?.git);
         case 'bin.nginx':
             return trimValue(config.settings?.bin?.nginx);
+        case 'bin.pnpm':
+            return trimValue(config.settings?.bin?.pnpm);
         case 'proxy.nb-cli-root':
             return trimValue(config.settings?.proxy?.nbCliRoot);
         case 'proxy.caddy-driver':
@@ -217,6 +239,8 @@ export function getEffectiveCliConfigValue(config, key) {
             return '127.0.0.1';
         case 'default-api-host':
             return '127.0.0.1';
+        case 'default-portal-template':
+            return explicit ?? '';
         case 'update.policy':
             return explicit ?? DEFAULT_UPDATE_POLICY;
         case 'license.pkg-url':
@@ -225,6 +249,12 @@ export function getEffectiveCliConfigValue(config, key) {
             return trimValue(config.name) || DEFAULT_DOCKER_NETWORK;
         case 'docker.container-prefix':
             return trimValue(config.name) || DEFAULT_DOCKER_CONTAINER_PREFIX;
+        case 'nb-image-registry':
+            return explicit ?? (resolveCliLocale(undefined, { configuredLocale: trimValue(config.settings?.locale) }) === 'zh-CN'
+                ? 'aliyun'
+                : DEFAULT_NB_IMAGE_REGISTRY);
+        case 'nb-image-variant':
+            return explicit ?? DEFAULT_NB_IMAGE_VARIANT;
         case 'bin.docker':
             return DEFAULT_DOCKER_BIN;
         case 'bin.caddy':
@@ -233,6 +263,8 @@ export function getEffectiveCliConfigValue(config, key) {
             return DEFAULT_GIT_BIN;
         case 'bin.nginx':
             return DEFAULT_NGINX_BIN;
+        case 'bin.pnpm':
+            return DEFAULT_PNPM_BIN;
         case 'proxy.nb-cli-root':
             return explicit ?? resolveCliHomeRoot();
         case 'proxy.caddy-driver':
@@ -298,6 +330,20 @@ export function normalizeCliConfigValue(key, value) {
         }
         return driver;
     }
+    if (key === 'nb-image-registry') {
+        const registry = normalizeNbImageRegistry(normalized);
+        if (!registry) {
+            throw new Error(`Config key "${key}" must be one of: ${NB_IMAGE_REGISTRY_OPTIONS.join(', ')}`);
+        }
+        return registry;
+    }
+    if (key === 'nb-image-variant') {
+        const variant = normalizeNbImageVariant(normalized);
+        if (!variant) {
+            throw new Error(`Config key "${key}" must be one of: ${NB_IMAGE_VARIANT_OPTIONS.join(', ')}`);
+        }
+        return variant;
+    }
     return normalized;
 }
 export async function loadCliConfig(options = {}) {
@@ -339,6 +385,12 @@ export async function setCliConfigValue(key, value, options = {}) {
                 defaultApiHost: normalized,
             };
             break;
+        case 'default-portal-template':
+            config.settings.init = {
+                ...(config.settings.init ?? {}),
+                defaultPortalTemplate: normalized,
+            };
+            break;
         case 'update.policy':
             config.settings.update = {
                 ...(config.settings.update ?? {}),
@@ -363,6 +415,18 @@ export async function setCliConfigValue(key, value, options = {}) {
                 containerPrefix: normalized,
             };
             break;
+        case 'nb-image-registry':
+            config.settings.docker = {
+                ...(config.settings.docker ?? {}),
+                nbImageRegistry: normalized,
+            };
+            break;
+        case 'nb-image-variant':
+            config.settings.docker = {
+                ...(config.settings.docker ?? {}),
+                nbImageVariant: normalized,
+            };
+            break;
         case 'bin.docker':
             config.settings.bin = {
                 ...(config.settings.bin ?? {}),
@@ -387,6 +451,12 @@ export async function setCliConfigValue(key, value, options = {}) {
                 nginx: normalized,
             };
             break;
+        case 'bin.pnpm':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                pnpm: normalized,
+            };
+            break;
         case 'proxy.nb-cli-root':
             config.settings.proxy = {
                 ...(config.settings.proxy ?? {}),
@@ -456,6 +526,11 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.init.defaultApiHost;
             }
             break;
+        case 'default-portal-template':
+            if (config.settings.init) {
+                delete config.settings.init.defaultPortalTemplate;
+            }
+            break;
         case 'update.policy':
             if (config.settings.update) {
                 delete config.settings.update.policy;
@@ -476,6 +551,16 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.docker.containerPrefix;
             }
             break;
+        case 'nb-image-registry':
+            if (config.settings.docker) {
+                delete config.settings.docker.nbImageRegistry;
+            }
+            break;
+        case 'nb-image-variant':
+            if (config.settings.docker) {
+                delete config.settings.docker.nbImageVariant;
+            }
+            break;
         case 'bin.docker':
             if (config.settings.bin) {
                 delete config.settings.bin.docker;
@@ -496,6 +581,11 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.bin.nginx;
             }
             break;
+        case 'bin.pnpm':
+            if (config.settings.bin) {
+                delete config.settings.bin.pnpm;
+            }
+            break;
         case 'proxy.nb-cli-root':
             if (config.settings.proxy) {
                 delete config.settings.proxy.nbCliRoot;
@@ -556,6 +646,7 @@ const CONFIGURABLE_COMMAND_KEYS = {
     caddy: 'bin.caddy',
     git: 'bin.git',
     nginx: 'bin.nginx',
+    pnpm: 'bin.pnpm',
     yarn: 'bin.yarn',
 };
 export function isConfigurableCommandName(value) {

package/dist/lib/docker-image.js

@@ -9,7 +9,30 @@
 export const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
 export const DEFAULT_DOCKER_REGISTRY_ZH_CN = 'registry.cn-shanghai.aliyuncs.com/nocobase/nocobase';
 export const DEFAULT_DOCKER_VERSION = 'alpha';
+export const NB_IMAGE_REGISTRY_OPTIONS = ['dockerhub', 'aliyun'];
+export const DEFAULT_NB_IMAGE_REGISTRY = 'dockerhub';
+export const NB_IMAGE_VARIANT_OPTIONS = ['standard', 'no-nginx', 'full', 'full-no-nginx'];
+export const DEFAULT_NB_IMAGE_VARIANT = 'full';
 export const DOCKER_IMAGE_FULL_SUFFIX = '-full';
+export const DOCKER_IMAGE_NO_NGINX_SUFFIX = '-no-nginx';
+export const DOCKER_IMAGE_FULL_NO_NGINX_SUFFIX = '-full-no-nginx';
+export const DEFAULT_KINGBASE_IMAGE = 'registry.cn-shanghai.aliyuncs.com/nocobase/kingbase:v009r001c001b0030_single_x86';
+const OFFICIAL_DOCKER_REGISTRY_REPOSITORIES = {
+    dockerhub: DEFAULT_DOCKER_REGISTRY,
+    aliyun: DEFAULT_DOCKER_REGISTRY_ZH_CN,
+};
+const DEFAULT_BUILTIN_DB_IMAGES = {
+    postgres: 'postgres:16',
+    mysql: 'mysql:8',
+    mariadb: 'mariadb:11',
+    kingbase: DEFAULT_KINGBASE_IMAGE,
+};
+const ALIYUN_BUILTIN_DB_IMAGES = {
+    postgres: 'registry.cn-shanghai.aliyuncs.com/nocobase/postgres:16',
+    mysql: 'registry.cn-shanghai.aliyuncs.com/nocobase/mysql:8',
+    mariadb: 'registry.cn-shanghai.aliyuncs.com/nocobase/mariadb:11',
+    kingbase: DEFAULT_KINGBASE_IMAGE,
+};
 const OFFICIAL_FULL_IMAGE_REGISTRIES = new Set([
     DEFAULT_DOCKER_REGISTRY,
     DEFAULT_DOCKER_REGISTRY_ZH_CN,
@@ -17,21 +40,86 @@ const OFFICIAL_FULL_IMAGE_REGISTRIES = new Set([
 function trimValue(value) {
     return String(value ?? '').trim();
 }
+export function normalizeNbImageRegistry(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return NB_IMAGE_REGISTRY_OPTIONS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+export function normalizeNbImageVariant(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return NB_IMAGE_VARIANT_OPTIONS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+export function resolveOfficialDockerRegistry(value) {
+    const registry = normalizeNbImageRegistry(value) ?? DEFAULT_NB_IMAGE_REGISTRY;
+    return OFFICIAL_DOCKER_REGISTRY_REPOSITORIES[registry];
+}
+export function inferNbImageRegistryFromRepository(value) {
+    const repository = trimValue(value);
+    return Object.entries(OFFICIAL_DOCKER_REGISTRY_REPOSITORIES).find(([, candidate]) => candidate === repository)?.[0];
+}
+function hasKnownVariantSuffix(tag) {
+    return (tag.endsWith(DOCKER_IMAGE_FULL_NO_NGINX_SUFFIX) ||
+        tag.endsWith(DOCKER_IMAGE_NO_NGINX_SUFFIX) ||
+        tag.endsWith(DOCKER_IMAGE_FULL_SUFFIX));
+}
 export function shouldUseFullDockerImageTag(registry) {
     return OFFICIAL_FULL_IMAGE_REGISTRIES.has(trimValue(registry));
 }
-export function normalizeDockerImageTag(registry, version) {
+export function normalizeDockerImageTag(registry, version, options) {
     const tag = trimValue(version) || DEFAULT_DOCKER_VERSION;
-    if (!shouldUseFullDockerImageTag(registry)) {
+    if (hasKnownVariantSuffix(tag)) {
         return tag;
     }
-    return tag.endsWith(DOCKER_IMAGE_FULL_SUFFIX)
-        ? tag
-        : `${tag}${DOCKER_IMAGE_FULL_SUFFIX}`;
+    const explicitVariant = normalizeNbImageVariant(options?.variant) ?? normalizeNbImageVariant(options?.defaultVariant);
+    const inferredVariant = shouldUseFullDockerImageTag(registry) ? DEFAULT_NB_IMAGE_VARIANT : 'standard';
+    const variant = explicitVariant ?? inferredVariant;
+    switch (variant) {
+        case 'standard':
+            return tag;
+        case 'no-nginx':
+            return `${tag}${DOCKER_IMAGE_NO_NGINX_SUFFIX}`;
+        case 'full':
+            return `${tag}${DOCKER_IMAGE_FULL_SUFFIX}`;
+        case 'full-no-nginx':
+            return `${tag}${DOCKER_IMAGE_FULL_NO_NGINX_SUFFIX}`;
+    }
 }
 export function resolveDockerImageRef(registry, version, options) {
     const resolvedRegistry = trimValue(registry) || options?.defaultRegistry || DEFAULT_DOCKER_REGISTRY;
     const rawVersion = trimValue(version) || options?.defaultVersion || DEFAULT_DOCKER_VERSION;
-    const normalizedTag = normalizeDockerImageTag(resolvedRegistry, rawVersion);
+    const normalizedTag = normalizeDockerImageTag(resolvedRegistry, rawVersion, {
+        variant: options?.variant,
+        defaultVariant: options?.defaultVariant,
+    });
     return `${resolvedRegistry}:${normalizedTag}`;
 }
+function extractDockerImageTag(imageRef) {
+    const ref = trimValue(imageRef);
+    const lastSlashIndex = ref.lastIndexOf('/');
+    const lastColonIndex = ref.lastIndexOf(':');
+    if (lastColonIndex <= lastSlashIndex) {
+        return undefined;
+    }
+    return ref.slice(lastColonIndex + 1) || undefined;
+}
+export function resolveDockerImageContainerPort(imageRef) {
+    const tag = extractDockerImageTag(imageRef);
+    return tag?.endsWith(DOCKER_IMAGE_NO_NGINX_SUFFIX) ? '13000' : '80';
+}
+export function resolveBuiltinDbImage(dbDialect, options) {
+    const dialect = trimValue(dbDialect) || 'postgres';
+    const configuredRegistry = normalizeNbImageRegistry(options?.registry) ??
+        inferNbImageRegistryFromRepository(options?.registry) ??
+        DEFAULT_NB_IMAGE_REGISTRY;
+    const defaults = configuredRegistry === 'aliyun' ? ALIYUN_BUILTIN_DB_IMAGES : DEFAULT_BUILTIN_DB_IMAGES;
+    return defaults[dialect] ?? defaults.postgres;
+}