@nocobase/app-template-default 0.0.0-stage → 1.0.0-beta.57

package/server/config/ai.ts

@@ -0,0 +1,27 @@
+import type { AppConfigFactory } from '@nocobase/app-server/config';
+import {
+  defineAIConfig,
+  type AIApplicationConfig,
+} from '@nocobase/app-plugin-ai-employee/server/config';
+
+const ai: AppConfigFactory<AIApplicationConfig> = defineAIConfig({
+  // Map a secret onto the field of one service it sets, keyed by that
+  // service's name, such as
+  // `OPENAI_API_KEY: envString('llmServices.openai.options.apiKey')` or
+  // `GITHUB_MCP_TOKEN: envString('mcpServers.github.headers.Authorization')`.
+  env: {},
+  defaults: () => ({
+    storage: {},
+    aiEmployee: { storage: {} },
+    aiKnowledgeBase: {
+      storage: {},
+      vectorDatabases: [],
+      manifests: [],
+    },
+    llmServices: {},
+    skills: { paths: [] },
+    mcpServers: {},
+  }),
+});
+
+export default ai;

package/server/config/api.ts

@@ -0,0 +1,8 @@
+import type { AppConfigFactory } from '@nocobase/app-server/config';
+import { defineApiConfig, type ApiConfig } from '@nocobase/app-server/router';
+
+// Limits every /api request meets ahead of its route: bodyLimit, timeout and rateLimit. Each is off until config.yml
+// sets it; see the commented api section in config.example.yml. API_BODY_LIMIT and API_TIMEOUT set the first two.
+const api: AppConfigFactory<ApiConfig> = defineApiConfig();
+
+export default api;

package/server/config/app.ts

@@ -0,0 +1,40 @@
+import {
+  defineAppConfig,
+  envBoolean,
+  envString,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppIdentityConfig } from '@nocobase/app-server/config';
+import {
+  joinBasePath,
+  normalizeBasePath,
+  resolveAppNameFromBasePath,
+} from '@nocobase/app-server/support';
+
+const app: AppConfigFactory<AppIdentityConfig> = defineAppConfig({
+  env: {
+    APP_PUBLIC_ORIGIN: envString('publicOrigin', {
+      description:
+        'The origin browsers reach the application at, such as https://apps.example.com, for callbacks and redirects.',
+      required: false,
+    }),
+    APP_SAMPLE_DATA: envBoolean('sampleData', {
+      description:
+        'Load sample data while the database is first installed: seeds declared with sample: true and sampleDataToken registrations.',
+      required: false,
+      firstStartOnly: true,
+    }),
+  },
+  defaults: (runtime) => {
+    const { routing } = runtime;
+    const publicBasePath = normalizeBasePath(routing.publicBasePath || '/main');
+    return {
+      name: routing.name || resolveAppNameFromBasePath(publicBasePath, 'main'),
+      publicBasePath,
+      internalBasePath: routing.internalBasePath,
+      publicApiUrl: joinBasePath(publicBasePath, '/api'),
+    };
+  },
+});
+
+export default app;

package/server/config/auth.ts

@@ -0,0 +1,36 @@
+import type { AppConfigFactory } from '@nocobase/app-server/config';
+import { apiKey } from '@nocobase/app-plugin-api-keys/server';
+import {
+  defineAuthConfig,
+  type AuthConfig,
+} from '@nocobase/app-plugin-authentication/server';
+import { bearer, deviceAuthorization, username } from 'better-auth/plugins';
+
+/**
+ * The command-line clients that may sign in through the browser (`deviceAuthorization()`): `nocobase-cli`, the id
+ * `@nocobase/app-cli-client` sends unless a branded CLI names its own. Add the id of any other CLI that should sign in.
+ */
+const CLI_CLIENT_IDS: readonly string[] = ['nocobase-cli'];
+
+const auth: AppConfigFactory<AuthConfig> = defineAuthConfig({
+  defaults: {
+    plugins: [
+      username({ displayUsername: false }),
+      apiKey(),
+      // A CLI signs in through the browser (RFC 8628): it shows a code the person approves on `/device`, below the
+      // application's base path, and receives a session token it sends as `Authorization: Bearer` (`bearer()`).
+      deviceAuthorization({
+        verificationUri: '/device',
+        expiresIn: '10m',
+        interval: '5s',
+        validateClient: (clientId) => CLI_CLIENT_IDS.includes(clientId),
+      }),
+      bearer(),
+    ],
+    emailAndPassword: { enabled: true, autoSignIn: false },
+    session: { storeSessionInDatabase: true },
+    account: { encryptOAuthTokens: true },
+  },
+});
+
+export default auth;

package/server/config/authorization.ts

@@ -0,0 +1,18 @@
+import { defaultAccess } from '@nocobase/app-plugin-authz-default-access/server';
+import { sharingRules } from '@nocobase/app-plugin-authz-sharing-rules/server';
+import { restrictionRules } from '@nocobase/app-plugin-authz-restriction-rules/server';
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import { type AuthorizationConfig } from '@nocobase/app-plugin-authorization/server';
+
+// Permission sets, database, pages, settings, composites and workspace placement are built in.
+const authorization: AppConfigFactory<AuthorizationConfig> = defineAppConfig(
+  (_runtime) => ({
+    permissionSets: { rootSet: 'root', defaultSet: 'member' },
+    plugins: [defaultAccess(), sharingRules(), restrictionRules()],
+  }),
+);
+
+export default authorization;

package/server/config/caching.ts

@@ -0,0 +1,21 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { CachingConfig } from '@nocobase/caching';
+
+const caching: AppConfigFactory<CachingConfig> = defineAppConfig(
+  (_runtime) => ({
+    default: 'memory',
+    providers: {
+      memory: {
+        driver: 'memory',
+        defaultTtl: '5m',
+        maxSize: 2_000,
+        useClone: true,
+      },
+    },
+  }),
+);
+
+export default caching;

package/server/config/database.ts

@@ -0,0 +1,22 @@
+import {
+  connectionEnvironment,
+  defineAppDatabaseConfig,
+} from '@nocobase/app-server/database';
+
+/** Installed official drivers are loaded synchronously when first needed. */
+export default defineAppDatabaseConfig(
+  ({ paths }) => ({
+    default: 'main',
+    connections: {
+      main: {
+        dialect: 'sqlite',
+        filename: paths.storage('database.sqlite'),
+        schemaManagement: 'managed',
+        debug: false,
+      },
+    },
+  }),
+  // DB_DIALECT, DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME, DB_PASSWORD, DB_SSL and DB_FILENAME set the main
+  // connection. Another connection declares its own, such as connectionEnvironment('analytics', 'DB_ANALYTICS').
+  { env: connectionEnvironment('main') },
+);

package/server/config/drive.ts

@@ -0,0 +1,30 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppDriveConfig } from '@nocobase/drive';
+
+const drive: AppConfigFactory<AppDriveConfig> = defineAppConfig(({ paths }) => {
+  const disks: AppDriveConfig['disks'] = {
+    local: {
+      driver: 'fs',
+      location: paths.storage(),
+      visibility: 'private',
+    },
+    s3: {
+      driver: 's3',
+      bucket: '',
+      region: 'us-east-1',
+      forcePathStyle: false,
+      supportsACL: true,
+      credentials: {},
+      visibility: 'private',
+    },
+  };
+  return {
+    default: 'local',
+    disks,
+  };
+});
+
+export default drive;

package/server/config/i18n.ts

@@ -0,0 +1,17 @@
+import {
+  defineAppConfig,
+  envString,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppI18nConfig } from '@nocobase/app-server/i18n';
+
+const i18n: AppConfigFactory<AppI18nConfig> = defineAppConfig({
+  defaults: { defaultLocale: 'en-US' },
+  env: {
+    APP_DEFAULT_LOCALE: envString('defaultLocale', {
+      description: 'The language the application starts in, such as zh-CN.',
+    }),
+  },
+});
+
+export default i18n;

package/server/config/index.ts

@@ -0,0 +1,73 @@
+import {
+  defaultAppConfigs,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import auth from './auth.js';
+import authorization from './authorization.js';
+import notification from './notification.js';
+import secrets from './secrets.js';
+import session from './session.js';
+import server from './server.js';
+import spa from './spa.js';
+import logging from './logging.js';
+import drive from './drive.js';
+import queue from './queue.js';
+import jobs from './jobs.js';
+import scheduler from './scheduler.js';
+import caching from './caching.js';
+import i18n from './i18n.js';
+import app from './app.js';
+import api from './api.js';
+import database from './database.js';
+import snowflake from './snowflake.js';
+import ai from './ai.js';
+import workflow from './workflow.js';
+import users from './users.js';
+
+const defaultConfigs: AppConfigFactory<{
+  auth: ReturnType<typeof auth>;
+  authorization: ReturnType<typeof authorization>;
+  notification: ReturnType<typeof notification>;
+  secrets: ReturnType<typeof secrets>;
+  session: ReturnType<typeof session>;
+  server: ReturnType<typeof server>;
+  spa: ReturnType<typeof spa>;
+  logging: ReturnType<typeof logging>;
+  drive: ReturnType<typeof drive>;
+  queue: ReturnType<typeof queue>;
+  jobs: ReturnType<typeof jobs>;
+  scheduler: ReturnType<typeof scheduler>;
+  caching: ReturnType<typeof caching>;
+  i18n: ReturnType<typeof i18n>;
+  app: ReturnType<typeof app>;
+  api: ReturnType<typeof api>;
+  database: ReturnType<typeof database>;
+  snowflake: ReturnType<typeof snowflake>;
+  ai: ReturnType<typeof ai>;
+  workflow: ReturnType<typeof workflow>;
+  users: ReturnType<typeof users>;
+}> = defaultAppConfigs({
+  auth,
+  authorization,
+  notification,
+  secrets,
+  session,
+  server,
+  spa,
+  logging,
+  drive,
+  queue,
+  jobs,
+  scheduler,
+  caching,
+  i18n,
+  app,
+  api,
+  database,
+  snowflake,
+  ai,
+  workflow,
+  users,
+});
+
+export default defaultConfigs;

package/server/config/jobs.ts

@@ -0,0 +1,27 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppJobsConfig } from '@nocobase/app-server/jobs';
+
+/**
+ * Configurations the jobs service can run on. None is the default: until `jobs.default` names one, executors
+ * run on the built-in memory adapter, which serves one process and writes its state under storage/jobs when the
+ * application stops, and which is reported at startup outside development. Name `memory` to keep that choice without
+ * the report, or `redis` to run any number of instances with each firing executed once.
+ */
+const jobs: AppConfigFactory<AppJobsConfig> = defineAppConfig(({ paths }) => ({
+  memory: {
+    adapter: 'memory',
+    persistence: { path: paths.storage('jobs') },
+  },
+  redis: {
+    adapter: 'redis',
+    connection: { host: '127.0.0.1', port: 6379, db: 0 },
+    // Every firing leaves a finished job behind; keep the history bounded.
+    removeOnComplete: { count: 1000 },
+    removeOnFail: { age: 604_800 },
+  },
+}));
+
+export default jobs;

package/server/config/logging.ts

@@ -0,0 +1,23 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppLoggingConfig } from '@nocobase/app-server/logging';
+
+const logging: AppConfigFactory<AppLoggingConfig> = defineAppConfig(
+  (runtime) => ({
+    level: 'info',
+    file: {
+      enabled: true,
+      name: 'app',
+      retentionDays: 7,
+      maxFileSizeMB: 10,
+      maxTotalSizeMB: 500,
+    },
+    loggers: {
+      request: { file: { name: 'request' } },
+    },
+    console: { enabled: true, pretty: runtime.env.NODE_ENV !== 'production' },
+  }),
+);
+export default logging;

package/server/config/notification.ts

@@ -0,0 +1,11 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { NotificationConfig } from '@nocobase/app-plugin-notification/server';
+
+const notification: AppConfigFactory<NotificationConfig> = defineAppConfig(
+  (_runtime) => ({ channels: {} }),
+);
+
+export default notification;

package/server/config/queue.ts

@@ -0,0 +1,28 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppQueueConfig } from '@nocobase/app-server/queue';
+
+/**
+ * Configurations queues can run on. None is the default: until `queue.default` names one, queues run on the
+ * built-in memory configuration, which serves one process and writes its pending jobs under storage/queue when the
+ * application stops, and which is reported at startup outside development. Name `memory` to keep that choice without
+ * the report, or `redis` to share queues across instances.
+ */
+const queue: AppConfigFactory<AppQueueConfig> = defineAppConfig(
+  ({ paths }) => ({
+    memory: {
+      adapter: 'inMemory',
+      persistence: { path: paths.storage('queue') },
+    },
+    redis: {
+      adapter: 'redis',
+      connection: { host: '127.0.0.1', port: 6379, db: 0 },
+      removeOnComplete: { count: 1000 },
+      removeOnFail: { age: 604_800 },
+    },
+  }),
+);
+
+export default queue;

package/server/config/scheduler.ts

@@ -0,0 +1,23 @@
+import type { SchedulerConfig } from '@nocobase/app-plugin-scheduler/server';
+import {
+  defineAppConfig,
+  envString,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+
+/**
+ * The Scheduler plugin's settings. `jobs` names the `jobs` configuration its schedules run on; left out, they follow
+ * `jobs.default` like every other consumer. A name that `jobs` does not define stops the application from starting.
+ */
+const scheduler: AppConfigFactory<SchedulerConfig> = defineAppConfig({
+  env: {
+    SCHEDULER_JOBS: envString('jobs', {
+      description:
+        'The jobs configuration scheduled jobs run on; jobs.default when unset.',
+      required: false,
+    }),
+  },
+  defaults: () => ({}),
+});
+
+export default scheduler;

package/server/config/secrets.ts

@@ -0,0 +1,10 @@
+import type { AppConfigFactory } from '@nocobase/app-server/config';
+import {
+  defineSecretsConfig,
+  type SecretsConfig,
+} from '@nocobase/app-server/secrets';
+
+// The master keys, current first, come from config.yml or SECRETS_KEYS; nothing is defaulted here.
+const secrets: AppConfigFactory<SecretsConfig> = defineSecretsConfig();
+
+export default secrets;

package/server/config/server.ts

@@ -0,0 +1,26 @@
+import {
+  defineAppConfig,
+  envBoolean,
+  envInteger,
+  envString,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { NodeServerConfig } from '@nocobase/app-server/node';
+
+const server: AppConfigFactory<NodeServerConfig> = defineAppConfig({
+  defaults: { host: '127.0.0.1', port: 13000, startLog: true },
+  env: {
+    APP_SERVER_HOST: envString('host', {
+      description: 'The address the server listens on.',
+    }),
+    APP_SERVER_PORT: envInteger('port', {
+      description: 'The port the server listens on.',
+    }),
+    // `pnpm dev` sets it to false: it prints its own ready banner and public URL.
+    APP_SERVER_START_LOG: envBoolean('startLog', {
+      description: 'Whether the server logs its address once it is ready.',
+    }),
+  },
+});
+
+export default server;

package/server/config/session.ts

@@ -0,0 +1,60 @@
+import {
+  defineAppConfig,
+  envString,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { AppSessionConfigInput } from '@nocobase/app-server/session';
+import { normalizeBasePath } from '@nocobase/app-server/support';
+
+const session: AppConfigFactory<AppSessionConfigInput> = defineAppConfig({
+  env: {
+    SESSION_SECRET: envString('secret', {
+      description:
+        'The legacy session signing secret; keys are derived from SECRETS_KEYS when it is set.',
+      secret: true,
+      generate: 'secret',
+    }),
+  },
+  defaults: ({ paths, env, routing }) => ({
+    enabled: true,
+    default: 'memory',
+    cookie: {
+      name: 'nocobase_session',
+      // The application's own public base path, as `app.publicBasePath` resolves it: applications sharing an origin
+      // under different paths (`/crm`, `/acme`) each keep their own session cookie instead of overwriting one another's.
+      path: normalizeBasePath(routing.publicBasePath || '/main'),
+      secure: env.NODE_ENV === 'production',
+      httpOnly: true,
+      sameSite: 'lax' as const,
+      partitioned: false,
+      expireOnClose: false,
+    },
+    lifetime: {
+      absolute: '2h',
+      rolling: true,
+    },
+    previousSecrets: [],
+    gcLottery: { hits: 2, total: 100 },
+    stores: {
+      memory: {
+        driver: 'memory',
+        base: 'nocobase:session:',
+      },
+      fs: {
+        driver: 'fs',
+        base: paths.storage('sessions'),
+      },
+      redis: {
+        driver: 'redis',
+        host: '127.0.0.1',
+        port: 6379,
+        db: 0,
+        base: 'nocobase:session:',
+        tls: false,
+      },
+      null: { driver: 'null' },
+    },
+  }),
+});
+
+export default session;

package/server/config/snowflake.ts

@@ -0,0 +1,21 @@
+import {
+  defineAppConfig,
+  envInteger,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { SnowflakeIdGeneratorConfig } from '@nocobase/snowflake';
+import { SNOWFLAKE_EPOCH_SECONDS } from '@nocobase/snowflake';
+
+const snowflake: AppConfigFactory<SnowflakeIdGeneratorConfig> = defineAppConfig(
+  {
+    defaults: { workerId: 0, epoch: SNOWFLAKE_EPOCH_SECONDS },
+    env: {
+      SNOWFLAKE_WORKER_ID: envInteger('workerId', {
+        description:
+          'A worker ID unique to each concurrently running instance, 0 to 1023.',
+      }),
+    },
+  },
+);
+
+export default snowflake;

package/server/config/spa.ts

@@ -0,0 +1,24 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { SpaConfig } from '@nocobase/app-server/spa';
+
+const spa: AppConfigFactory<SpaConfig> = defineAppConfig({
+  defaults: ({ paths }) => ({
+    indexPath: paths.client('index.html'),
+  }),
+  env: {
+    // The Vite dev server `pnpm dev` proxies to; `false` or `0` serves the built client instead.
+    APP_VITE_DEV_URL: {
+      path: 'viteDevUrl',
+      description:
+        'The Vite dev server pnpm dev proxies the client to; false or 0 serves the built client.',
+      required: false,
+      parse: (value): string | null =>
+        value === 'false' || value === '0' ? null : value,
+    },
+  },
+});
+
+export default spa;

package/server/config/users.ts

@@ -0,0 +1,11 @@
+import type { AppConfigFactory } from '@nocobase/app-server/config';
+import {
+  defineUsersConfig,
+  type UsersConfig,
+} from '@nocobase/app-plugin-users/server/config';
+
+// The initial administrator comes from config.yml (users.initialAdmin) or INITIAL_ADMIN_USERNAME, INITIAL_ADMIN_EMAIL
+// and INITIAL_ADMIN_PASSWORD, read once while the user table is empty.
+const users: AppConfigFactory<UsersConfig> = defineUsersConfig();
+
+export default users;

package/server/config/workflow.ts

@@ -0,0 +1,24 @@
+import {
+  defineAppConfig,
+  type AppConfigFactory,
+} from '@nocobase/app-server/config';
+import type { WorkflowRuntimeConfig } from '@nocobase/app-plugin-workflow/server';
+import { resolveWorkflowRuntimeConfig } from '@nocobase/app-plugin-workflow/server';
+
+const workflow: AppConfigFactory<WorkflowRuntimeConfig> = defineAppConfig(
+  ({ paths, env }) =>
+    resolveWorkflowRuntimeConfig(
+      {
+        sourceRoot: paths.root('workflows'),
+        distRoot: paths.root('workflows'),
+        artifactDisk: 'local',
+        production: env.NODE_ENV === 'production',
+      },
+      {
+        rootDir: paths.root(),
+        serverDir: paths.server(),
+      },
+    ),
+);
+
+export default workflow;

package/server/config.ts

@@ -0,0 +1,24 @@
+import {
+  AppConfig,
+  resolveDefaultAppConfigFile,
+} from '@nocobase/app-server/config';
+import type { ResolvedAppRuntimeConfigContext } from '@nocobase/app-server/runtime';
+
+export function createAppConfig(
+  context: ResolvedAppRuntimeConfigContext,
+): AppConfig {
+  const config = new AppConfig();
+  const configuredPath =
+    context.configPath ?? context.environment.APP_CONFIG_FILE;
+  // Deployment configuration stays beside the compiled code directory.
+  const configPath =
+    configuredPath === undefined
+      ? resolveDefaultAppConfigFile(context.paths)
+      : context.paths.root(configuredPath);
+
+  // Environment variables are declared by the sections they set, in `env` of each `defineAppConfig`, and loaded
+  // above this file once the sections are known. `pnpm nocobase config env` lists them.
+  config.loadFile(configPath, { optional: configuredPath === undefined });
+
+  return config;
+}

package/server/embedded.ts

@@ -0,0 +1,23 @@
+import type { Application } from '@nocobase/app-server/application';
+import {
+  resolveAppRuntime,
+  startApplicationInScope,
+  type AppDisposer,
+  type AppScope,
+} from '@nocobase/app-server/runtime';
+
+import { createApp } from './app.js';
+import appRuntime from './runtime.js';
+
+export type { AppDisposer, AppScope };
+
+export type EmbeddedServer = Application;
+
+export async function createServer(scope: AppScope): Promise<EmbeddedServer> {
+  const runtime = await resolveAppRuntime(appRuntime, scope);
+  const app = createApp(runtime);
+
+  return startApplicationInScope(scope, app);
+}
+
+export default createServer;

package/server/locales/en-US.ts

@@ -0,0 +1,10 @@
+import type { LocaleResource } from '@nocobase/i18n';
+
+// The application's own server-side wording. It is empty because every string the server produces today belongs to a
+// plugin's namespace; add keys here as the application starts producing its own, and use `overrides` to reword a
+// plugin's.
+const enUS = {};
+
+export type AppServerResource = LocaleResource<typeof enUS>;
+
+export default enUS;