@technomoron/mail-magic 1.0.9 → 1.0.12

package/CHANGES

@@ -1,3 +1,27 @@
+Version 1.0.12 (2026-01-31)
+
+- Removed the hard dependency on `@technomoron/mail-magic-admin` so installs
+  are fully standalone unless the admin UI is explicitly added.
+
+Version 1.0.11 (2026-01-31)
+
+- Scoped the client package to `@technomoron/mail-magic-client` and refreshed
+  documentation to match.
+- Added root build shortcuts for server/client/admin packages and aligned the
+  release tag pattern for the client workflow.
+- Added a TypeScript-based CLI bin so global installs expose `mail-magic`.
+
+Version 1.0.10 (2026-01-31)
+
+- Added authenticated asset uploads via `POST /api/v1/assets`, supporting
+  domain and template-scoped targets with path validation and ownership checks.
+- Mount optional admin UI at `/` when the admin package is installed, while
+  leaving API and asset routes unchanged.
+- Expanded automated testing with new Vitest unit/integration coverage, an
+  SMTP harness, and fixture-backed template/asset scenarios.
+- Updated the client library/CLI to support transactional/form uploads,
+  attachments, and config-driven bulk pushes.
+
 Version 1.0.9 (2026-01-02)
 
 - Default CONFIG_PATH to ./data and document the data-rooted layout, including

package/README.md

@@ -9,6 +9,7 @@ Mail Magic is a TypeScript service for managing, templating, and delivering tran
 - Nodemailer transport configuration driven by environment variables
 - SQLite-backed data models for domains, users, forms, and templates
 - Type-safe configuration loader powered by `@technomoron/env-loader`
+- Bundled admin UI (placeholder) served at the root path `/`
 
 ## Getting Started
 
@@ -30,6 +31,10 @@ During development you can run `npm run dev` for a watch mode that recompiles on
 
 When `DB_AUTO_RELOAD` is enabled the service watches `init-data.json` and refreshes templates and forms without a restart.
 
+### Admin UI
+
+The server mounts the admin UI at `/` when the `@technomoron/mail-magic-admin` package is installed. This is a placeholder Vue app today, but it is already wired so future admin features can live there without changing the server routing.
+
 ### Template assets and inline resources
 
 - Keep any non-inline files (images, attachments, etc.) under `<CONFIG_PATH>/<domain>/assets`. Mail Magic rewrites `asset('logo.png')` to the public route `/asset/<domain>/logo.png` (or whatever you set via `ASSET_ROUTE`).

package/dist/api/assets.js

@@ -1,10 +1,157 @@
 import fs from 'fs';
 import path from 'path';
 import { ApiError, ApiModule } from '@technomoron/api-server-base';
+import { api_domain } from '../models/domain.js';
+import { api_form } from '../models/form.js';
+import { api_txmail } from '../models/txmail.js';
+import { api_user } from '../models/user.js';
 import { decodeComponent, sendFileAsync } from '../util.js';
 const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
 const SEGMENT_PATTERN = /^[a-zA-Z0-9._-]+$/;
 export class AssetAPI extends ApiModule {
+    getBodyValue(body, ...keys) {
+        for (const key of keys) {
+            const value = body[key];
+            if (Array.isArray(value) && value.length > 0) {
+                return String(value[0]);
+            }
+            if (value !== undefined && value !== null) {
+                return String(value);
+            }
+        }
+        return '';
+    }
+    async assertDomainAndUser(apireq) {
+        const domainName = this.getBodyValue(apireq.req.body ?? {}, 'domain');
+        if (!domainName) {
+            throw new ApiError({ code: 401, message: 'Missing domain' });
+        }
+        const user = await api_user.findOne({ where: { token: apireq.token } });
+        if (!user) {
+            throw new ApiError({ code: 401, message: `Invalid/Unknown API Key/Token '${apireq.token}'` });
+        }
+        const dbdomain = await api_domain.findOne({ where: { name: domainName } });
+        if (!dbdomain) {
+            throw new ApiError({ code: 401, message: `Unable to look up the domain ${domainName}` });
+        }
+        if (dbdomain.user_id !== user.user_id) {
+            throw new ApiError({ code: 403, message: `Domain ${domainName} is not owned by this user` });
+        }
+        apireq.domain = dbdomain;
+        apireq.user = user;
+    }
+    normalizeSubdir(value) {
+        if (!value) {
+            return '';
+        }
+        const cleaned = value.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '');
+        if (!cleaned) {
+            return '';
+        }
+        const segments = cleaned.split('/').filter(Boolean);
+        for (const segment of segments) {
+            if (!SEGMENT_PATTERN.test(segment)) {
+                throw new ApiError({ code: 400, message: `Invalid path segment "${segment}"` });
+            }
+        }
+        return path.join(...segments);
+    }
+    async moveUploadedFiles(files, targetDir) {
+        await fs.promises.mkdir(targetDir, { recursive: true });
+        for (const file of files) {
+            const filename = path.basename(file.originalname || '');
+            if (!filename || !SEGMENT_PATTERN.test(filename)) {
+                throw new ApiError({ code: 400, message: `Invalid filename "${file.originalname}"` });
+            }
+            const destination = path.join(targetDir, filename);
+            if (destination === file.path) {
+                continue;
+            }
+            try {
+                await fs.promises.rename(file.path, destination);
+            }
+            catch {
+                await fs.promises.copyFile(file.path, destination);
+                await fs.promises.unlink(file.path);
+            }
+        }
+    }
+    async resolveTemplateDir(apireq) {
+        const body = apireq.req.body ?? {};
+        const templateTypeRaw = this.getBodyValue(body, 'templateType', 'template_type', 'type');
+        const templateName = this.getBodyValue(body, 'template', 'name', 'idname', 'formid');
+        const locale = this.getBodyValue(body, 'locale');
+        if (!templateTypeRaw) {
+            throw new ApiError({ code: 400, message: 'Missing templateType for template asset upload' });
+        }
+        if (!templateName) {
+            throw new ApiError({ code: 400, message: 'Missing template name/id for template asset upload' });
+        }
+        const templateType = templateTypeRaw.toLowerCase();
+        const domainId = apireq.domain.domain_id;
+        const deflocale = this.server.storage.deflocale || '';
+        if (templateType === 'tx') {
+            const template = (await api_txmail.findOne({ where: { name: templateName, domain_id: domainId, locale } })) ||
+                (await api_txmail.findOne({ where: { name: templateName, domain_id: domainId, locale: deflocale } })) ||
+                (await api_txmail.findOne({ where: { name: templateName, domain_id: domainId } }));
+            if (!template) {
+                throw new ApiError({
+                    code: 404,
+                    message: `Template "${templateName}" not found for domain "${apireq.domain.name}"`
+                });
+            }
+            const candidate = path.resolve(this.server.storage.configpath, template.filename);
+            const configRoot = this.server.storage.configpath;
+            const normalizedRoot = configRoot.endsWith(path.sep) ? configRoot : configRoot + path.sep;
+            if (!candidate.startsWith(normalizedRoot)) {
+                throw new ApiError({ code: 400, message: 'Template path escapes config root' });
+            }
+            return path.dirname(candidate);
+        }
+        if (templateType === 'form') {
+            const form = (await api_form.findOne({ where: { idname: templateName, domain_id: domainId, locale } })) ||
+                (await api_form.findOne({ where: { idname: templateName, domain_id: domainId, locale: deflocale } })) ||
+                (await api_form.findOne({ where: { idname: templateName, domain_id: domainId } }));
+            if (!form) {
+                throw new ApiError({
+                    code: 404,
+                    message: `Form "${templateName}" not found for domain "${apireq.domain.name}"`
+                });
+            }
+            const candidate = path.resolve(this.server.storage.configpath, form.filename);
+            const configRoot = this.server.storage.configpath;
+            const normalizedRoot = configRoot.endsWith(path.sep) ? configRoot : configRoot + path.sep;
+            if (!candidate.startsWith(normalizedRoot)) {
+                throw new ApiError({ code: 400, message: 'Template path escapes config root' });
+            }
+            return path.dirname(candidate);
+        }
+        throw new ApiError({ code: 400, message: 'templateType must be "tx" or "form"' });
+    }
+    async postAssets(apireq) {
+        await this.assertDomainAndUser(apireq);
+        const rawFiles = Array.isArray(apireq.req.files) ? apireq.req.files : [];
+        if (!rawFiles.length) {
+            throw new ApiError({ code: 400, message: 'No files uploaded' });
+        }
+        const body = apireq.req.body ?? {};
+        const subdir = this.normalizeSubdir(this.getBodyValue(body, 'path', 'dir'));
+        const templateType = this.getBodyValue(body, 'templateType', 'template_type', 'type');
+        let targetRoot;
+        if (templateType) {
+            targetRoot = await this.resolveTemplateDir(apireq);
+        }
+        else {
+            targetRoot = path.join(this.server.storage.configpath, apireq.domain.name, 'assets');
+        }
+        const candidate = path.resolve(targetRoot, subdir);
+        const normalizedRoot = targetRoot.endsWith(path.sep) ? targetRoot : targetRoot + path.sep;
+        if (candidate !== targetRoot && !candidate.startsWith(normalizedRoot)) {
+            throw new ApiError({ code: 400, message: 'Invalid asset target path' });
+        }
+        await this.moveUploadedFiles(rawFiles, candidate);
+        return [200, { Status: 'OK' }];
+    }
     async getAsset(apiReq) {
         const domain = decodeComponent(apiReq.req.params.domain);
         if (!domain || !DOMAIN_PATTERN.test(domain)) {
@@ -66,6 +213,12 @@ export class AssetAPI extends ApiModule {
         const route = this.server.storage.env.ASSET_ROUTE;
         const normalizedRoute = route.startsWith('/') ? route : `/${route}`;
         return [
+            {
+                method: 'post',
+                path: '/v1/assets',
+                handler: (apiReq) => this.postAssets(apiReq),
+                auth: { type: 'yes', req: 'any' }
+            },
             {
                 method: 'get',
                 path: `${normalizedRoute}/:domain/*`,

package/dist/api/forms.js

@@ -144,6 +144,8 @@ export class FormAPI extends ApiModule {
         console.log('Files:', JSON.stringify(apireq.req.files, null, 2));
         */
         const rawFiles = Array.isArray(apireq.req.files) ? apireq.req.files : [];
+        const domainRecord = await api_domain.findOne({ where: { domain_id: form.domain_id } });
+        await this.server.storage.relocateUploads(domainRecord?.name ?? null, rawFiles);
         const attachments = rawFiles.map((file) => ({
             filename: file.originalname,
             path: file.path

package/dist/api/mailer.js

@@ -146,6 +146,7 @@ export class MailerAPI extends ApiModule {
             throw new ApiError({ code: 500, message: `Unable to locate sender for ${template.name}` });
         }
         const rawFiles = Array.isArray(apireq.req.files) ? apireq.req.files : [];
+        await this.server.storage.relocateUploads(apireq.domain?.name ?? null, rawFiles);
         const templateAssets = Array.isArray(template.files) ? template.files : [];
         const attachments = [
             ...templateAssets.map((file) => ({

package/dist/bin/mail-magic.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import dotenv from 'dotenv';
+import { startMailMagicServer } from '../index.js';
+const args = process.argv.slice(2);
+function usage(exitCode = 0) {
+    const out = exitCode === 0 ? process.stdout : process.stderr;
+    out.write(`Usage: mail-magic [--env PATH]\n\n` +
+        `Options:\n` +
+        `  -e, --env PATH   Path to .env (defaults to ./.env)\n` +
+        `  -h, --help       Show this help\n`);
+    process.exit(exitCode);
+}
+let envPath;
+for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '-h' || arg === '--help') {
+        usage(0);
+    }
+    if (arg === '-e' || arg === '--env') {
+        const next = args[i + 1];
+        if (!next) {
+            console.error('Error: --env requires a path');
+            usage(1);
+        }
+        envPath = next;
+        i += 1;
+        continue;
+    }
+    if (arg.startsWith('--env=')) {
+        envPath = arg.slice('--env='.length);
+        continue;
+    }
+    console.error(`Error: unknown option ${arg}`);
+    usage(1);
+}
+const resolvedEnvPath = path.resolve(envPath || '.env');
+if (!fs.existsSync(resolvedEnvPath)) {
+    console.error(`Error: env file not found at ${resolvedEnvPath}`);
+    process.exit(1);
+}
+process.chdir(path.dirname(resolvedEnvPath));
+const result = dotenv.config({ path: resolvedEnvPath });
+if (result.error) {
+    console.error('Error: failed to load env file');
+    console.error(result.error);
+    process.exit(1);
+}
+async function main() {
+    try {
+        const { store, env } = await startMailMagicServer();
+        console.log(`Using config path: ${store.configpath}`);
+        console.log(`mail-magic server listening on ${env.API_HOST}:${env.API_PORT}`);
+    }
+    catch (error) {
+        console.error('Failed to start mail-magic server');
+        console.error(error);
+        process.exit(1);
+    }
+}
+await main();

package/dist/index.js

@@ -1,4 +1,7 @@
-import { pathToFileURL } from 'node:url';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { AssetAPI } from './api/assets.js';
 import { FormAPI } from './api/forms.js';
 import { MailerAPI } from './api/mailer.js';
@@ -9,7 +12,7 @@ function buildServerConfig(store, overrides) {
     return {
         apiHost: env.API_HOST,
         apiPort: env.API_PORT,
-        uploadPath: env.UPLOAD_PATH,
+        uploadPath: store.getUploadStagingPath(),
         debug: env.DEBUG,
         apiBasePath: '',
         swaggerEnabled: env.SWAGGER_ENABLED,
@@ -21,6 +24,7 @@ export async function createMailMagicServer(overrides = {}) {
     const store = await new mailStore().init();
     const config = buildServerConfig(store, overrides);
     const server = new mailApiServer(config, store).api(new MailerAPI()).api(new FormAPI()).api(new AssetAPI());
+    mountAdminUi(server, store);
     return { server, store, env: store.env };
 }
 export async function startMailMagicServer(overrides = {}) {
@@ -52,3 +56,58 @@ const isDirectExecution = (() => {
 if (isDirectExecution) {
     void bootMailMagic();
 }
+function resolveAdminDist() {
+    const require = createRequire(import.meta.url);
+    try {
+        const pkgPath = require.resolve('@technomoron/mail-magic-admin/package.json');
+        const pkgDir = path.dirname(pkgPath);
+        const distPath = path.join(pkgDir, 'dist');
+        if (fs.existsSync(distPath)) {
+            return distPath;
+        }
+    }
+    catch {
+        // ignore
+    }
+    const fallbackBase = path.dirname(fileURLToPath(import.meta.url));
+    const fallback = path.resolve(fallbackBase, '..', '..', 'mail-magic-admin', 'dist');
+    if (fs.existsSync(fallback)) {
+        return fallback;
+    }
+    return null;
+}
+function mountAdminUi(server, store) {
+    const distPath = resolveAdminDist();
+    if (!distPath) {
+        store.print_debug('Admin UI not found, skipping static mount');
+        return;
+    }
+    const assetRoute = store.env.ASSET_ROUTE.startsWith('/') ? store.env.ASSET_ROUTE : `/${store.env.ASSET_ROUTE}`;
+    const indexPath = path.join(distPath, 'index.html');
+    const hasIndex = fs.existsSync(indexPath);
+    server.app.get('*', (req, res, next) => {
+        if (req.method !== 'GET') {
+            next();
+            return;
+        }
+        if (req.path.startsWith('/api') || req.path.startsWith(assetRoute)) {
+            next();
+            return;
+        }
+        const requestPath = req.path === '/' ? 'index.html' : req.path.replace(/^\//, '');
+        const resolvedPath = path.resolve(distPath, requestPath);
+        if (!resolvedPath.startsWith(`${distPath}${path.sep}`) && resolvedPath !== distPath) {
+            next();
+            return;
+        }
+        if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) {
+            res.sendFile(resolvedPath);
+            return;
+        }
+        if (!hasIndex) {
+            next();
+            return;
+        }
+        res.sendFile(indexPath);
+    });
+}

package/dist/store/envloader.js

@@ -43,7 +43,7 @@ export const envOptions = defineEnvOptions({
     },
     CONFIG_PATH: {
         description: 'Path to directory where config files are located',
-        default: './config/'
+        default: './data/'
     },
     DB_USER: {
         description: 'Database username for API database'
@@ -102,7 +102,7 @@ export const envOptions = defineEnvOptions({
         default: ''
     },
     UPLOAD_PATH: {
-        description: 'Path for attached files',
-        default: './uploads/'
+        description: 'Path for attached files. Use {domain} to scope per domain.',
+        default: './{domain}/uploads'
     }
 });

package/dist/store/store.js

@@ -38,6 +38,8 @@ export class mailStore {
     keys = {};
     configpath = '';
     deflocale;
+    uploadTemplate;
+    uploadStagingPath;
     print_debug(msg) {
         if (this.env.DEBUG) {
             console.log(msg);
@@ -46,6 +48,59 @@ export class mailStore {
     config_filename(name) {
         return path.resolve(path.join(this.configpath, name));
     }
+    resolveUploadPath(domainName) {
+        const raw = this.env.UPLOAD_PATH ?? '';
+        const hasDomainToken = raw.includes('{domain}');
+        const expanded = hasDomainToken && domainName ? raw.replaceAll('{domain}', domainName) : raw;
+        if (!expanded) {
+            return '';
+        }
+        if (path.isAbsolute(expanded)) {
+            return expanded;
+        }
+        const base = hasDomainToken ? this.configpath : process.cwd();
+        return path.resolve(base, expanded);
+    }
+    getUploadStagingPath() {
+        if (!this.env.UPLOAD_PATH) {
+            return '';
+        }
+        if (this.uploadTemplate) {
+            return this.uploadStagingPath || path.resolve(this.configpath, '_uploads');
+        }
+        return this.resolveUploadPath();
+    }
+    async relocateUploads(domainName, files) {
+        if (!this.uploadTemplate || !domainName || !files?.length) {
+            return;
+        }
+        const targetDir = this.resolveUploadPath(domainName);
+        if (!targetDir) {
+            return;
+        }
+        await fs.promises.mkdir(targetDir, { recursive: true });
+        await Promise.all(files.map(async (file) => {
+            if (!file?.path) {
+                return;
+            }
+            const basename = path.basename(file.path);
+            const destination = path.join(targetDir, basename);
+            if (destination === file.path) {
+                return;
+            }
+            try {
+                await fs.promises.rename(file.path, destination);
+            }
+            catch {
+                await fs.promises.copyFile(file.path, destination);
+                await fs.promises.unlink(file.path);
+            }
+            file.path = destination;
+            if (file.destination !== undefined) {
+                file.destination = targetDir;
+            }
+        }));
+    }
     async load_api_keys(cfgpath) {
         const keyfile = path.resolve(cfgpath, 'api-keys.json');
         if (fs.existsSync(keyfile)) {
@@ -61,8 +116,18 @@ export class mailStore {
         const env = (this.env = await EnvLoader.createConfigProxy(envOptions, { debug: true }));
         EnvLoader.genTemplate(envOptions, '.env-dist');
         const p = env.CONFIG_PATH;
-        this.configpath = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
+        this.configpath = path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
         console.log(`Config path is ${this.configpath}`);
+        if (env.UPLOAD_PATH && env.UPLOAD_PATH.includes('{domain}')) {
+            this.uploadTemplate = env.UPLOAD_PATH;
+            this.uploadStagingPath = path.resolve(this.configpath, '_uploads');
+            try {
+                fs.mkdirSync(this.uploadStagingPath, { recursive: true });
+            }
+            catch (err) {
+                this.print_debug(`Unable to create upload staging path: ${err}`);
+            }
+        }
         // this.keys = await this.load_api_keys(this.configpath);
         this.transport = await create_mail_transport(env);
         this.api_db = await connect_api_db(this);

package/package.json

@@ -1,11 +1,21 @@
 {
 	"name": "@technomoron/mail-magic",
-	"version": "1.0.9",
+	"version": "1.0.12",
 	"main": "dist/index.js",
 	"type": "module",
+	"bin": {
+		"mail-magic": "dist/bin/mail-magic.js"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"CHANGES",
+		"TUTORIAL.MD"
+	],
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/technomoron/mail-magic.git"
+		"url": "git+https://github.com/technomoron/mail-magic.git",
+		"directory": "packages/mail-magic"
 	},
 	"pnpm": {
 		"onlyBuiltDependencies": [
@@ -20,6 +30,8 @@
 		"dev": "NODE_ENV=development nodemon --watch 'src/**/*.ts' --watch 'config/**/*.*' --watch '.env' --exec 'tsx' src/index.ts",
 		"run": "NODE_ENV=production npm run start",
 		"build": "tsc",
+		"postbuild": "node scripts/add-shebang.cjs",
+		"prepack": "npm run build",
 		"test": "vitest run",
 		"test:watch": "vitest",
 		"scrub": "rm -rf ./node_modules/ ./dist/ pnpm-lock.yaml",
@@ -42,6 +54,7 @@
 		"@technomoron/env-loader": "^1.0.8",
 		"@technomoron/unyuck": "^1.0.4",
 		"bcryptjs": "^3.0.2",
+		"dotenv": "^16.4.5",
 		"email-addresses": "^5.0.0",
 		"html-to-text": "^9.0.5",
 		"nodemailer": "^6.10.1",
@@ -69,7 +82,7 @@
 		"smtp-server": "^3.18.0",
 		"supertest": "^7.1.4",
 		"tsx": "^4.20.5",
-		"typescript": "^5.9.2",
+		"typescript": "^5.9.3",
 		"vitest": "^4.0.16"
 	},
 	"homepage": "https://github.com/technomoron/mail-magic#readme",

package/.do-realease.sh

@@ -1,54 +0,0 @@
-#!/bin/sh
-
-VERSION=$(node -p "require('./package.json').version")
-
-echo "Creating release for ${VERSION}"
-
-if [ -n "$(git status --porcelain)" ]; then
-	echo "Working tree is not clean. Commit or stash changes before release." >&2
-	exit 1
-fi
-
-UPSTREAM=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || true)
-if [ -z "$UPSTREAM" ]; then
-	echo "No upstream configured for $(git rev-parse --abbrev-ref HEAD). Set upstream before release." >&2
-	exit 1
-fi
-
-if ! git fetch --quiet; then
-	echo "Failed to fetch remote updates. Check your network or remote access." >&2
-	exit 1
-fi
-
-set -- $(git rev-list --left-right --count "${UPSTREAM}...HEAD")
-BEHIND_COUNT=$1
-AHEAD_COUNT=$2
-
-if [ "$BEHIND_COUNT" -ne 0 ] || [ "$AHEAD_COUNT" -ne 0 ]; then
-	echo "Branch is not in sync with ${UPSTREAM} (behind ${BEHIND_COUNT}, ahead ${AHEAD_COUNT})." >&2
-	echo "Pull/push until the branch matches upstream before release." >&2
-	exit 1
-fi
-
-if ! npm whoami >/dev/null 2>&1; then
-	echo "Not logged into npm. Run 'npm login' before release." >&2
-	exit 1
-fi
-
-if git rev-parse -q --verify "refs/tags/v${VERSION}" >/dev/null; then
-	echo "Tag v${VERSION} already exists. Aborting." >&2
-	exit 1
-fi
-
-git tag -a "v${VERSION}" -m "Release version ${VERSION}"
-git push origin "v${VERSION}"
-
-# detect prerelease versions (contains a hyphen)
-if echo "$VERSION" | grep -q "-"; then
-  TAG=$(echo "$VERSION" | sed 's/^[0-9.]*-\([a-zA-Z0-9]*\).*/\1/')
-  echo "Detected prerelease. Publishing with tag '$TAG'"
-  npm publish --tag "$TAG" --access=public
-else
-  echo "Stable release. Publishing as latest"
-  npm publish --access=public
-fi

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = tab
-indent_size = 4
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true

package/.env-dist

@@ -1,71 +0,0 @@
-# Specifies the environment in which the app is running Possible values: development, production, staging
-NODE_ENV=development
-
-# Defines the port on which the app listens. Default 3780 [number]
-API_PORT=3776
-
-# Sets the local IP address for the API to listen at
-API_HOST=0.0.0.0
-
-# Reload init-data.db automatically on change [boolean]
-DB_AUTO_RELOAD=true
-
-# Whether to force sync on table definitions (ALTER TABLE) [boolean]
-DB_FORCE_SYNC=false
-
-# Sets the public URL for the API (i.e. https://ml.example.com:3790)
-API_URL=http://localhost:3776
-
-# Enable the Swagger/OpenAPI endpoint [boolean]
-SWAGGER_ENABLED=false
-
-# Path to expose the Swagger/OpenAPI spec (default: /api/swagger when enabled)
-SWAGGER_PATH=
-
-# Route prefix exposed for config assets
-ASSET_ROUTE=/asset
-
-# Path to directory where config files are located
-CONFIG_PATH=./data/
-
-# Database username for API database
-DB_USER=
-
-# Password for API database
-DB_PASS=
-
-# Name of API database. Filename for sqlite3, database name for others
-DB_NAME=maildata
-
-# Host of API database
-DB_HOST=localhost
-
-# Database type of WP database Possible values: sqlite
-DB_TYPE=sqlite
-
-# Log SQL statements [boolean]
-DB_LOG=false
-
-# Enable debug output, including nodemailer and API [boolean]
-DEBUG=false
-
-# Hostname of SMTP sending host
-SMTP_HOST=localhost
-
-# SMTP host server port [number]
-SMTP_PORT=587
-
-# Use secure connection to SMTP host (SSL/TSL) [boolean]
-SMTP_SECURE=false
-
-# Reject bad cert/TLS connection to SMTP host [boolean]
-SMTP_TLS_REJECT=false
-
-# Username for SMTP host
-SMTP_USER=
-
-# Password for SMTP host
-SMTP_PASSWORD=
-
-# Path for attached files. Use {domain} to scope per domain.
-UPLOAD_PATH=./{domain}/uploads