webspresso 0.0.67 → 0.0.69

package/README.md

@@ -129,6 +129,17 @@ If you select a database:
 - `models/` directory is created
 - `DATABASE_URL` is added to `.env.example` with a template
 
+**Scaffold: `config/` and environment files**
+
+New projects include:
+
+- **`config/load-env.js`** — loads, in order, `.env`, `.env.local`, `.env.${NODE_ENV}`, and `.env.${NODE_ENV}.local` (each file overrides keys from earlier ones).
+- **`config/env.schema.js`** — validates `process.env` with **Zod** before the app starts (`PORT`, `NODE_ENV`, i18n vars, `BASE_URL`, optional `DATABASE_URL`).
+- **`config/app.js`** — returns `createApp()` options (paths; if `webspresso.db.js` exists, also **`createDatabase`** as `db`).
+- **`server.js`** — calls `loadEnv()`, then `createApp(getCreateAppOptions())`, then `listen` using the parsed `PORT`.
+
+Copy **`.env.example`** to **`.env`** (and use `.env.local` for machine-specific overrides). Patterns such as `.env.development.local` are gitignored via `.env.*.local`.
+
 **Seed Data Generation:**
 After selecting a database, you'll be asked if you want to generate seed data:
 - If yes, `@faker-js/faker` is added to dependencies
@@ -2041,6 +2052,45 @@ const { app } = createApp({
 
 List query parameters: `page`, `perPage`, `sort`, `order`, `include`, `trashed` (`only` / `include` when the model uses soft delete), plus **equality filters** on real columns (unknown keys are ignored).
 
+### File upload plugin
+
+Registers **POST** `multipart/form-data` (field name **`file`** by default) and stores the file via a pluggable provider. The framework ships with **`createLocalFileProvider({ destDir, publicBasePath })`** (writes to disk and returns a public URL path). Use **`mimeAllowlist`** / **`extensionAllowlist`** and **`maxBytes`** (default **10 MiB**) on the server; production apps should prefer an explicit MIME allowlist.
+
+**Setup:**
+
+```javascript
+const { createApp, uploadPlugin, adminPanelPlugin } = require('webspresso');
+
+const { app } = createApp({
+  pagesDir: './pages',
+  publicDir: './public',
+  db,
+  plugins: [
+    uploadPlugin({
+      path: '/api/upload',
+      local: {
+        destDir: './public/uploads',
+        publicBasePath: '/uploads',
+      },
+      maxBytes: 10 * 1024 * 1024,
+      mimeAllowlist: ['image/jpeg', 'image/png', 'application/pdf'],
+      extensionAllowlist: ['jpg', 'jpeg', 'png', 'pdf'],
+      middleware: [], // optional Express handlers (e.g. session auth)
+      fieldName: 'file',
+    }),
+    adminPanelPlugin({
+      db,
+      // uploadUrl optional: defaults to app.get('webspresso.uploadPath') set by uploadPlugin
+    }),
+  ],
+});
+```
+
+- **ORM:** `zdb.file({ maxLength: 2048, nullable: true })` — string column for the stored public URL or path; migrations use `table.string(..., maxLength)`.
+- **Admin:** the panel reads **`settings.uploadUrl`** from the registry (set automatically when `uploadPlugin` is registered **before** `adminPanelPlugin`, or pass **`adminPanelPlugin({ uploadUrl: '/api/upload' })`**). File fields (`type: 'file'` or `customFields` type `file-upload`) POST to that URL with credentials.
+- **Response:** `{ url, publicUrl, key? }` — clients typically persist **`url`** / **`publicUrl`** in the model.
+- **Custom storage:** `uploadPlugin({ provider: { async put({ buffer, originalName, mimeType, size, req }) { return { publicUrl: '...' }; } } })`.
+
 ### Health check plugin
 
 Exposes a lightweight **GET** endpoint for load balancers and orchestrators (Kubernetes, Docker healthcheck, etc.). **Enabled by default** in all environments; set `enabled: false` to turn it off.
@@ -2101,10 +2151,15 @@ In production, keep the plugin disabled or protect it with `authorize` / your ow
 
 ## Development
 
+Native addons (**better-sqlite3**, **bcrypt**, **sharp**) are compiled for your current Node ABI. After switching Node major versions (e.g. nvm, fnm, Volta), run **`npm run rebuild:native`** or a clean install: `rm -rf node_modules && npm ci`. **chokidar** is not ABI-tied like those drivers; if file watching misbehaves, reinstall dependencies. The repo includes [`.nvmrc`](.nvmrc) (Node 20 LTS) as a known-good default for this project.
+
 ```bash
 # Install dependencies
 npm install
 
+# If you changed Node version and see MODULE_VERSION or .node load errors:
+npm run rebuild:native
+
 # Run tests
 npm test
 
@@ -2113,6 +2168,9 @@ npm run test:watch
 
 # Run tests with coverage
 npm run test:coverage
+
+# Micro-benchmarks (Vitest bench; also runs in CI on the test matrix)
+npm run bench
 ```
 
 ## License

package/bin/commands/doctor.js

@@ -107,6 +107,29 @@ function registerCommand(program) {
         warnings += 1;
       }
 
+      console.log('\nEnvironment files');
+      console.log('-----------------');
+
+      const envExamplePath = path.join(cwd, '.env.example');
+      const envPath = path.join(cwd, '.env');
+      if (fs.existsSync(envExamplePath)) {
+        line('✓', '.env.example present');
+      } else {
+        line('○', 'No .env.example (optional; new scaffolds include one)');
+      }
+      if (fs.existsSync(envPath)) {
+        line('✓', '.env present');
+      } else if (fs.existsSync(envExamplePath)) {
+        line('⚠', 'No .env — copy .env.example to .env if the app expects env vars');
+        warnings += 1;
+      } else {
+        line('○', 'No .env (fine if you do not use dotenv in this project)');
+      }
+      const loadEnvPath = path.join(cwd, 'config', 'load-env.js');
+      if (fs.existsSync(loadEnvPath)) {
+        line('✓', 'config/load-env.js present (dotenv chain scaffold)');
+      }
+
       console.log('\nDatabase config');
       console.log('---------------');
 

package/bin/commands/new.js

@@ -9,6 +9,30 @@ const path = require('path');
 const { runInstallation, startDevServer } = require('../utils/project');
 const { getSeedFileTemplate } = require('../utils/seed');
 
+/** `.` / `./` mean scaffold into the current working directory */
+function isCurrentDirAlias(name) {
+  if (name == null || typeof name !== 'string') return false;
+  const t = name.trim();
+  return t === '.' || t === './';
+}
+
+/** package.json `name` from a directory path (must match interactive validator rules) */
+function derivePackageNameFromDir(dirPath) {
+  const base = path.basename(path.resolve(dirPath));
+  if (/^[a-z0-9-_]+$/i.test(base)) return base;
+  return 'webspresso-app';
+}
+
+function assertNotExistingWebspressoProject(projectPath) {
+  if (
+    fs.existsSync(path.join(projectPath, 'server.js')) ||
+    fs.existsSync(path.join(projectPath, 'pages'))
+  ) {
+    console.error('❌ Target directory already contains a Webspresso project (server.js or pages/).');
+    process.exit(1);
+  }
+}
+
 function registerCommand(program) {
   program
     .command('new [project-name]')
@@ -16,9 +40,12 @@ function registerCommand(program) {
     .option('-t, --template <template>', 'Template to use (minimal, full)', 'minimal')
     .option('--no-tailwind', 'Skip Tailwind CSS setup')
     .option('-i, --install', 'Auto install dependencies and build CSS')
+    .option('-y, --yes', 'Non-interactive: no database, skip install unless -i/--install, skip dev server')
     .action(async (projectNameArg, options) => {
       const useTailwind = options.tailwind !== false;
       const autoInstall = options.install === true;
+      const skipPrompts = options.yes === true;
+      const stdinNotTty = !process.stdin.isTTY;
       
       let projectName;
       let projectPath;
@@ -43,27 +70,27 @@ function registerCommand(program) {
           useCurrentDir = true;
           projectPath = process.cwd();
           
-          // Check for existing Webspresso files
-          if (fs.existsSync(path.join(projectPath, 'server.js')) || 
-              fs.existsSync(path.join(projectPath, 'pages'))) {
-            console.error('❌ Current directory already contains a Webspresso project!');
-            process.exit(1);
-          }
+          assertNotExistingWebspressoProject(projectPath);
           
           // Warn if there are existing files
           if (hasExistingFiles) {
-            const { continueAnyway } = await inquirer.prompt([
-              {
-                type: 'confirm',
-                name: 'continueAnyway',
-                message: '⚠️  Current directory is not empty. Continue anyway?',
-                default: false
+            const autoProceed = skipPrompts || stdinNotTty;
+            if (autoProceed) {
+              console.log('ℹ️  Current directory is not empty; scaffolding alongside existing files.');
+            } else {
+              const { continueAnyway } = await inquirer.prompt([
+                {
+                  type: 'confirm',
+                  name: 'continueAnyway',
+                  message: '⚠️  Current directory is not empty. Continue anyway?',
+                  default: true
+                }
+              ]);
+              
+              if (!continueAnyway) {
+                console.log('Cancelled.');
+                process.exit(0);
               }
-            ]);
-            
-            if (!continueAnyway) {
-              console.log('Cancelled.');
-              process.exit(0);
             }
           }
           
@@ -102,53 +129,92 @@ function registerCommand(program) {
           projectName = dirName;
           projectPath = path.resolve(dirName);
         }
+      } else if (isCurrentDirAlias(projectNameArg)) {
+        useCurrentDir = true;
+        projectPath = process.cwd();
+        projectName = derivePackageNameFromDir(projectPath);
+        
+        assertNotExistingWebspressoProject(projectPath);
+        
+        const currentDirFiles = fs.readdirSync(projectPath);
+        const hasExistingFiles = currentDirFiles.some((f) => !f.startsWith('.'));
+        if (hasExistingFiles) {
+          const autoProceed = skipPrompts || stdinNotTty;
+          if (autoProceed) {
+            console.log('ℹ️  Current directory is not empty; scaffolding alongside existing files.');
+          } else {
+            const { continueAnyway } = await inquirer.prompt([
+              {
+                type: 'confirm',
+                name: 'continueAnyway',
+                message: '⚠️  Current directory is not empty. Continue anyway?',
+                default: true
+              }
+            ]);
+            
+            if (!continueAnyway) {
+              console.log('Cancelled.');
+              process.exit(0);
+            }
+          }
+        }
       } else {
-        projectName = projectNameArg;
-        projectPath = path.resolve(projectNameArg);
+        const trimmed = projectNameArg.trim();
+        projectPath = path.resolve(trimmed);
+        projectName = derivePackageNameFromDir(projectPath);
         
         if (fs.existsSync(projectPath)) {
-          console.error(`❌ Directory ${projectName} already exists!`);
+          console.error(`❌ Directory ${trimmed} already exists!`);
           process.exit(1);
         }
       }
       
       console.log(`\n🚀 Creating new Webspresso project: ${projectName}\n`);
       
-      // Ask about database
-      const { useDatabase, databaseType } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'useDatabase',
-          message: 'Will you use a database?',
-          default: false
-        },
-        {
-          type: 'list',
-          name: 'databaseType',
-          message: 'Which database?',
-          choices: [
-            { name: 'SQLite (better-sqlite3)', value: 'better-sqlite3' },
-            { name: 'PostgreSQL (pg)', value: 'pg' },
-            { name: 'MySQL (mysql2)', value: 'mysql2' },
-            { name: 'None', value: null }
-          ],
-          default: 'better-sqlite3',
-          when: (answers) => answers.useDatabase
-        }
-      ]);
-      
-      // Ask about seed data if database is selected
+      let useDatabase = false;
+      let databaseType = null;
       let useSeed = false;
-      if (useDatabase && databaseType) {
-        const { generateSeed } = await inquirer.prompt([
+      
+      if (skipPrompts) {
+        useDatabase = false;
+        databaseType = null;
+        useSeed = false;
+      } else {
+        const dbAnswers = await inquirer.prompt([
           {
             type: 'confirm',
-            name: 'generateSeed',
-            message: 'Generate seed data based on existing models?',
+            name: 'useDatabase',
+            message: 'Will you use a database?',
             default: false
+          },
+          {
+            type: 'list',
+            name: 'databaseType',
+            message: 'Which database?',
+            choices: [
+              { name: 'SQLite (better-sqlite3)', value: 'better-sqlite3' },
+              { name: 'PostgreSQL (pg)', value: 'pg' },
+              { name: 'MySQL (mysql2)', value: 'mysql2' },
+              { name: 'None', value: null }
+            ],
+            default: 'better-sqlite3',
+            when: (answers) => answers.useDatabase
           }
         ]);
-        useSeed = generateSeed;
+        useDatabase = dbAnswers.useDatabase;
+        databaseType = dbAnswers.databaseType;
+        
+        if (useDatabase && databaseType) {
+          const { generateSeed } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'generateSeed',
+              message: 'Generate seed data based on existing models?',
+              default: false
+            }
+          ]);
+          useSeed = generateSeed;
+        }
       }
       
       // Create directory structure (skip root if using current dir)
@@ -159,6 +225,7 @@ function registerCommand(program) {
       fs.mkdirSync(path.join(projectPath, 'pages', 'locales'), { recursive: true });
       fs.mkdirSync(path.join(projectPath, 'views'), { recursive: true });
       fs.mkdirSync(path.join(projectPath, 'public'), { recursive: true });
+      fs.mkdirSync(path.join(projectPath, 'config'), { recursive: true });
       
       // Create models directory if database is selected
       if (useDatabase && databaseType) {
@@ -177,7 +244,8 @@ function registerCommand(program) {
         },
         dependencies: {
           webspresso: '*',
-          dotenv: '^16.3.1'
+          dotenv: '^16.3.1',
+          zod: '^3.23.0'
         }
       };
       
@@ -203,28 +271,108 @@ function registerCommand(program) {
         JSON.stringify(packageJson, null, 2) + '\n'
       );
       
-      // Create server.js
-      const serverJs = `require('dotenv').config();
-const { createApp } = require('webspresso');
+      // config/load-env.js — dotenv chain (last file wins for each key)
+      const loadEnvJs = `const fs = require('fs');
 const path = require('path');
+const dotenv = require('dotenv');
+
+/**
+ * Load env files in order: .env, .env.local, .env.<NODE_ENV>, .env.<NODE_ENV>.local
+ * @param {string} [rootDir] Project root (default: parent of config/)
+ */
+function loadEnv(rootDir) {
+  const root = rootDir || path.resolve(__dirname, '..');
+  const loadFile = (name) => {
+    const full = path.join(root, name);
+    if (fs.existsSync(full)) {
+      dotenv.config({ path: full, override: true });
+    }
+  };
+  loadFile('.env');
+  loadFile('.env.local');
+  const mode = process.env.NODE_ENV || 'development';
+  loadFile(\`.env.\${mode}\`);
+  loadFile(\`.env.\${mode}.local\`);
+}
+
+module.exports = { loadEnv };
+`;
+
+      const envSchemaJs = `const { z } = require('zod');
 
-const { app } = createApp({
-  pagesDir: path.join(__dirname, 'pages'),
-  viewsDir: path.join(__dirname, 'views'),
-  publicDir: path.join(__dirname, 'public')
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.coerce.number().int().positive().default(3000),
+  DEFAULT_LOCALE: z.string().min(1).default('en'),
+  SUPPORTED_LOCALES: z.string().min(1).default('en,de'),
+  BASE_URL: z.string().url().default('http://localhost:3000'),
+  DATABASE_URL: z.string().optional(),
 });
 
-const PORT = process.env.PORT || 3000;
+let _parsed = null;
+
+function parseEnv() {
+  if (_parsed) return _parsed;
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    console.error('Invalid environment variables:');
+    console.error(result.error.format());
+    process.exit(1);
+  }
+  _parsed = result.data;
+  return _parsed;
+}
+
+module.exports = { envSchema, parseEnv };
+`;
+
+      const appConfigJs = `const path = require('path');
+const fs = require('fs');
+const { parseEnv } = require('./env.schema');
+
+function getCreateAppOptions() {
+  parseEnv();
+  const rootDir = path.resolve(__dirname, '..');
+  const options = {
+    pagesDir: path.join(rootDir, 'pages'),
+    viewsDir: path.join(rootDir, 'views'),
+    publicDir: path.join(rootDir, 'public'),
+  };
+  const dbFile = path.join(rootDir, 'webspresso.db.js');
+  if (fs.existsSync(dbFile)) {
+    const { createDatabase } = require('webspresso');
+    const knexConfig = require(dbFile);
+    options.db = createDatabase(knexConfig);
+  }
+  return options;
+}
+
+module.exports = getCreateAppOptions;
+`;
+
+      const serverJs = `const { loadEnv } = require('./config/load-env');
+loadEnv();
+
+const { createApp } = require('webspresso');
+const getCreateAppOptions = require('./config/app');
+const { parseEnv } = require('./config/env.schema');
+
+const env = parseEnv();
+const { app } = createApp(getCreateAppOptions());
 
-app.listen(PORT, () => {
-  console.log(\`🚀 Server running at http://localhost:\${PORT}\`);
+app.listen(env.PORT, () => {
+  console.log(\`🚀 Server running at http://localhost:\${env.PORT}\`);
 });
 `;
-      
+
+      fs.writeFileSync(path.join(projectPath, 'config', 'load-env.js'), loadEnvJs);
+      fs.writeFileSync(path.join(projectPath, 'config', 'env.schema.js'), envSchemaJs);
+      fs.writeFileSync(path.join(projectPath, 'config', 'app.js'), appConfigJs);
       fs.writeFileSync(path.join(projectPath, 'server.js'), serverJs);
       
-      // Create .env.example
-      let envExample = `PORT=3000
+      // Create .env.example (see config/load-env.js for merge order)
+      let envExample = `# Copy to .env and adjust. Optional overrides: .env.local, .env.<NODE_ENV>, .env.<NODE_ENV>.local
+PORT=3000
 NODE_ENV=development
 DEFAULT_LOCALE=en
 SUPPORTED_LOCALES=en,de
@@ -308,10 +456,11 @@ BASE_URL=http://localhost:3000
         fs.writeFileSync(path.join(projectPath, 'seeds', 'index.js'), seedIndex);
       }
       
-      // Create .gitignore
+      // Create .gitignore (.env optional: teams often commit a non-secret .env for local defaults)
       const gitignore = `node_modules/
 .env
 .env.local
+.env.*.local
 .DS_Store
 coverage/
 *.log
@@ -482,10 +631,18 @@ Webspresso project
 
 \`\`\`bash
 npm install
+cp .env.example .env
 npm run dev
 \`\`\`
 
 Visit http://localhost:3000
+
+## Configuration
+
+- **\`config/load-env.js\`** — loads \`.env\`, \`.env.local\`, then \`.env.$NODE_ENV\` and \`.env.$NODE_ENV.local\` (later files override keys).
+- **\`config/env.schema.js\`** — [Zod](https://zod.dev) schema for \`process.env\`; fails fast on invalid values.
+- **\`config/app.js\`** — builds options passed to \`createApp()\` (paths; adds \`db\` when \`webspresso.db.js\` exists).
+- **\`server.js\`** — calls \`loadEnv()\`, then \`createApp(getCreateAppOptions())\`.
 `;
       
       fs.writeFileSync(path.join(projectPath, 'README.md'), readme);
@@ -561,28 +718,46 @@ module.exports = {
       if (autoInstall) {
         await runInstallation(projectPath, useTailwind);
         
-        // Ask if user wants to start dev server
-        const { shouldStartDev } = await inquirer.prompt([
-          {
-            type: 'confirm',
-            name: 'shouldStartDev',
-            message: 'Start development server?',
-            default: true
-          }
-        ]);
-        
-        if (shouldStartDev) {
-          startDevServer(projectPath, useTailwind);
-        } else {
+        if (skipPrompts) {
           console.log('✅ Project ready!\n');
           console.log('Start developing:');
           if (!useCurrentDir) {
             console.log(`  cd ${projectName}`);
           }
           console.log('  npm run dev\n');
+        } else {
+          const { shouldStartDev } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'shouldStartDev',
+              message: 'Start development server?',
+              default: true
+            }
+          ]);
+          
+          if (shouldStartDev) {
+            startDevServer(projectPath, useTailwind);
+          } else {
+            console.log('✅ Project ready!\n');
+            console.log('Start developing:');
+            if (!useCurrentDir) {
+              console.log(`  cd ${projectName}`);
+            }
+            console.log('  npm run dev\n');
+          }
+        }
+      } else if (skipPrompts) {
+        console.log('\n✅ Project created successfully!\n');
+        console.log('Next steps:');
+        if (!useCurrentDir) {
+          console.log(`  cd ${projectName}`);
+        }
+        console.log('  npm install');
+        if (useTailwind) {
+          console.log('  npm run build:css');
         }
+        console.log('  npm run dev\n');
       } else {
-        // Ask if user wants to install dependencies
         const { shouldInstall } = await inquirer.prompt([
           {
             type: 'confirm',
@@ -595,7 +770,6 @@ module.exports = {
         if (shouldInstall) {
           await runInstallation(projectPath, useTailwind);
           
-          // Ask if user wants to start dev server
           const { shouldStartDev } = await inquirer.prompt([
             {
               type: 'confirm',

package/core/orm/migrations/scaffold.js

@@ -112,6 +112,12 @@ function generateColumnLine(columnName, meta) {
       parts.push(`table.text('${columnName}')`);
       break;
 
+    case 'file': {
+      const fileLen = meta.maxLength || 2048;
+      parts.push(`table.string('${columnName}', ${fileLen})`);
+      break;
+    }
+
     case 'float':
       parts.push(`table.float('${columnName}')`);
       break;

package/core/orm/schema-helpers.js

@@ -420,6 +420,25 @@ function createSchemaHelpers(z) {
       }, z);
     },
 
+    /**
+     * File / URL column (stored as varchar; value is public URL or path from upload)
+     * @param {Partial<import('./types').ColumnMeta>} [options={}]
+     * @returns {SchemaBuilder}
+     */
+    file(options = {}) {
+      const { maxLength = 2048, nullable = false, ...rest } = options;
+      let schema = z.string().max(maxLength);
+      if (nullable) {
+        schema = schema.nullable().optional();
+      }
+      return createSchemaBuilder(schema, {
+        type: 'file',
+        maxLength,
+        nullable,
+        ...rest,
+      }, z);
+    },
+
     /**
      * Integer column
      * @param {Partial<import('./types').ColumnMeta>} [options={}]

package/core/orm/types.js

@@ -9,7 +9,7 @@
 // ============================================================================
 
 /**
- * @typedef {'id'|'string'|'text'|'integer'|'bigint'|'float'|'decimal'|'boolean'|'date'|'datetime'|'timestamp'|'json'|'array'|'enum'|'uuid'|'nanoid'} ColumnType
+ * @typedef {'id'|'string'|'text'|'file'|'integer'|'bigint'|'float'|'decimal'|'boolean'|'date'|'datetime'|'timestamp'|'json'|'array'|'enum'|'uuid'|'nanoid'} ColumnType
  */
 
 /**

package/index.d.ts

@@ -94,7 +94,10 @@ export function mountPages(
 
 export function filePathToRoute(filePath: string, pagesDir: string): string;
 
-export function extractMethodFromFilename(filename: string): string | null;
+export function extractMethodFromFilename(filename: string): {
+  method: string;
+  baseName: string;
+};
 
 export function scanDirectory(
   dir: string,
@@ -531,3 +534,33 @@ export interface RestResourcePluginOptions {
 export function restResourcePlugin(options?: RestResourcePluginOptions): WebspressoPlugin;
 
 export function ormCacheAdminPlugin(options: { db: DatabaseInstance }): WebspressoPlugin;
+
+/** Multipart upload storage (e.g. local disk or S3). */
+export interface UploadStorageProvider {
+  put(args: {
+    buffer?: Buffer;
+    stream?: NodeJS.ReadableStream;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    req: Request;
+  }): Promise<{ publicUrl: string; key?: string }>;
+}
+
+export interface UploadPluginOptions {
+  path?: string;
+  provider?: UploadStorageProvider;
+  local?: { destDir?: string; publicBasePath?: string };
+  maxBytes?: number;
+  mimeAllowlist?: string[] | null;
+  extensionAllowlist?: string[] | null;
+  middleware?: RequestHandler | RequestHandler[];
+  fieldName?: string;
+}
+
+export function uploadPlugin(options?: UploadPluginOptions): WebspressoPlugin;
+
+export function createLocalFileProvider(options?: {
+  destDir?: string;
+  publicBasePath?: string;
+}): UploadStorageProvider;