@karmaniverous/smoz 0.2.4 → 0.2.6

package/dist/cli/index.cjs

@@ -495,13 +495,17 @@ const collect = async (root) => {
     buckets.serverless.sort();
     return buckets;
 };
-const makeImports = (root, files) => {
-    return files.map((abs) => {
-        const rel = toPosix$1(path.relative(root, abs));
-        const noExt = withoutTsExt(rel);
-        return `import '@/${noExt}';`;
-    });
-};
+/**
+ * Build ESM import lines using POSIX-relative specifiers from the generated
+ * file directory (app/generated) to each target file. Avoids "@/" alias so
+ * dynamic import in the inline server works reliably under tsx.
+ */
+const makeImports = (root, outDir, files) => files.map((abs) => {
+    const relFromOut = toPosix$1(path.relative(outDir, abs));
+    const noExt = withoutTsExt(relFromOut);
+    const spec = noExt.startsWith('.') ? noExt : `./${noExt}`;
+    return `import '${spec}';`;
+});
 const buildFile = (imports) => {
     if (imports.length === 0)
         return `${HEADER}\n`;
@@ -509,10 +513,10 @@ const buildFile = (imports) => {
 };
 const runRegister = async (root) => {
     const buckets = await collect(root);
-    const lambdaImports = makeImports(root, buckets.lambda);
-    const openapiImports = makeImports(root, buckets.openapi);
-    const serverlessImports = makeImports(root, buckets.serverless);
     const outDir = path.join(root, 'app', 'generated');
+    const lambdaImports = makeImports(root, outDir, buckets.lambda);
+    const openapiImports = makeImports(root, outDir, buckets.openapi);
+    const serverlessImports = makeImports(root, outDir, buckets.serverless);
     const fnsPath = path.join(outDir, 'register.functions.ts');
     const oaiPath = path.join(outDir, 'register.openapi.ts');
     const srvPath = path.join(outDir, 'register.serverless.ts');
@@ -529,11 +533,6 @@ const runRegister = async (root) => {
     return { wrote };
 };
 
-/* Dev loop orchestrator
- * - Watches author sources; debounces bursts; runs tasks in order: register → openapi.
- * - Optional local serving (--local inline|offline).
- * - Stage/env: seeds process.env with concrete values for the selected stage.
- */
 const runDev = async (root, opts) => {
     const verbose = !!opts.verbose;
     const stage = typeof opts.stage === 'string'
@@ -547,7 +546,8 @@ const runDev = async (root, opts) => {
         if (verbose)
             console.warn('[dev] env seeding warning:', e.message);
     }
-    const mode = opts.local;
+    const modeInitial = opts.local;
+    let mode = modeInitial;
     const port = typeof opts.port === 'number' ? opts.port : 0;
     if (verbose) {
         console.log(`[dev] options: register=${String(opts.register)} ` +
@@ -633,8 +633,18 @@ const runDev = async (root, opts) => {
         offline = await launchOffline(root, { stage, port, verbose });
     }
     else if (mode === 'inline') {
-        inlineChild = await launchInline(root, { stage, port, verbose });
-    } // Watch sources
+        try {
+            inlineChild = await launchInline(root, { stage, port, verbose });
+        }
+        catch (e) {
+            const msg = e.message;
+            console.warn('[dev] inline unavailable:', msg);
+            console.warn('[dev] Falling back to serverless-offline.');
+            mode = 'offline';
+            offline = await launchOffline(root, { stage, port, verbose });
+        }
+    }
+    // Watch sources
     const globs = [
         path.join(root, 'app', 'functions', '**', 'lambda.ts'),
         path.join(root, 'app', 'functions', '**', 'openapi.ts'),
@@ -742,29 +752,53 @@ const seedEnvForStage = async (root, stage, verbose) => {
 };
 // Inline local runner: spawn tsx to run a TS server script.
 const launchInline = async (root, opts) => {
-    const { spawn } = await import('node:child_process');
+    const { spawn, spawnSync } = await import('node:child_process');
     const path = await import('node:path');
     const fs = await import('node:fs');
-    const tsxCli = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
-    const entry = path.resolve(root, 'src', 'cli', 'local', 'inline.server.ts');
+    // Resolve packaged inline server from the project root so this works
+    // both when running the built CLI and via tsx on sources.
+    const entry = path.resolve(root, 'dist', 'mjs', 'cli', 'inline-server.js');
     if (!fs.existsSync(entry)) {
-        throw new Error('inline server entry missing: src/cli/local/inline.server.ts');
+        throw new Error('inline server entry missing in package (dist/mjs/cli/inline-server.js)');
     }
-    const args = [tsxCli, entry];
-    if (!fs.existsSync(tsxCli)) {
-        // Fallback to PATH resolution
-        args.shift();
-        args.unshift(process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
+    // Prefer project-local tsx; otherwise probe PATH for tsx availability
+    const tsxCli = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
+    let cmd;
+    let args;
+    let useShell = false;
+    let tsxAvailable = false;
+    if (fs.existsSync(tsxCli)) {
+        tsxAvailable = true;
+        cmd = process.execPath;
+        // Pass the TSX CLI script followed by our entry. On Windows, avoid
+        // putting unknown flags before the script to prevent Node from treating
+        // them as its own options. Enable tsconfig-paths via env only.
+        args = [tsxCli, entry];
     }
     else {
-        args.unshift(process.execPath);
+        // Probe PATH: tsx --version
+        const probe = spawnSync(process.platform === 'win32' ? 'tsx.cmd' : 'tsx', ['--version'], { shell: true });
+        if (typeof probe.status === 'number' && probe.status === 0)
+            tsxAvailable = true;
+        cmd = process.platform === 'win32' ? 'tsx.cmd' : 'tsx';
+        // Invoke tsx from PATH with just the script entry; rely on
+        // TSX_TSCONFIG_PATHS=1 in the environment for path alias resolution.
+        args = [entry];
+        useShell = true;
+    }
+    if (!tsxAvailable) {
+        throw new Error('tsx not found (required for inline). Install "tsx" as a devDependency or use --local offline.');
     }
-    const spawnChild = () => spawn(args[0], args.slice(1), {
+    const spawnChild = () => spawn(cmd, args, {
         cwd: root,
         stdio: 'inherit',
-        shell: !args[0].endsWith('.js'),
+        shell: useShell,
+        // Enable tsconfig paths resolution for "@/..." via environment;
+        // avoids passing CLI flags that can confuse Node on Windows.
+        // Keep additional SMOZ_* env for server configuration.
         env: {
             ...process.env,
+            TSX_TSCONFIG_PATHS: '1',
             SMOZ_STAGE: opts.stage,
             SMOZ_PORT: String(opts.port),
             SMOZ_VERBOSE: opts.verbose ? '1' : '',
@@ -1426,7 +1460,7 @@ const main = () => {
         .option('-l, --local [mode]', 'Local server mode: inline|offline', 'inline')
         .option('-s, --stage <name>', 'Stage name (default inferred)')
         .option('-p, --port <n>', 'Port (0=random)', (v) => Number(v), 0)
-        .option('-v, --verbose', 'Verbose logging', false)
+        .option('-V, --verbose', 'Verbose logging', false)
         .action(async (opts) => {
         try {
             const cfg = readSmozConfig(root).cliDefaults?.dev ?? {};

package/dist/mjs/cli/inline-server.js

@@ -0,0 +1,296 @@
+import http from 'node:http';
+import { URL, pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+const firstVal = (v) => Array.isArray(v) ? v[0] : v;
+const arrVal = (v) => typeof v === 'string' ? [v] : Array.isArray(v) ? v : undefined;
+const toHeaders = (raw) => {
+    const single = {};
+    const multi = {};
+    for (const [k, v] of Object.entries(raw)) {
+        const fv = firstVal(v);
+        const av = arrVal(v);
+        if (typeof fv === 'string')
+            single[k] = fv;
+        if (Array.isArray(av))
+            multi[k] = av;
+    }
+    return { single, multi };
+};
+const readBody = (req) => new Promise((resolve) => {
+    const chunks = [];
+    req.on('data', (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c))));
+    req.on('end', () => {
+        resolve(Buffer.concat(chunks).toString('utf8'));
+    });
+    req.on('error', () => {
+        resolve('');
+    });
+});
+const match = (segs, pathName) => {
+    const parts = pathName
+        .replace(/^\/+|\/+$/g, '')
+        .split('/')
+        .filter(Boolean);
+    if (parts.length !== segs.length)
+        return { ok: false, params: {} };
+    const params = {};
+    for (let i = 0; i < segs.length; i += 1) {
+        const seg = segs[i];
+        const p = parts[i];
+        if (seg.literal) {
+            if (seg.literal !== p)
+                return { ok: false, params: {} };
+        }
+        else if (seg.key) {
+            params[seg.key] = p;
+        }
+    }
+    return { ok: true, params };
+};
+const toEvent = async (req, route, params) => {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    const { single, multi } = toHeaders(req.headers);
+    const method = (req.method ?? '').toUpperCase();
+    const stage = process.env.SMOZ_STAGE ?? 'dev';
+    const search = new URLSearchParams(url.search);
+    const query = {};
+    const mquery = {};
+    for (const key of Array.from(new Set(search.keys()))) {
+        const vals = search.getAll(key);
+        if (vals.length > 0) {
+            query[key] = vals[0];
+            mquery[key] = vals;
+        }
+    }
+    let body = '';
+    if (method !== 'GET' && method !== 'HEAD') {
+        body = await readBody(req);
+    }
+    return {
+        httpMethod: method,
+        headers: single,
+        multiValueHeaders: multi,
+        body,
+        isBase64Encoded: false,
+        path: url.pathname,
+        queryStringParameters: Object.keys(query).length ? query : {},
+        multiValueQueryStringParameters: Object.keys(mquery).length ? mquery : {},
+        pathParameters: Object.keys(params).length ? params : {},
+        stageVariables: null,
+        resource: route.pattern,
+        requestContext: {
+            accountId: 'acc',
+            apiId: 'inline',
+            httpMethod: method,
+            identity: {},
+            path: url.pathname,
+            stage,
+            requestId: String(Date.now()),
+            requestTimeEpoch: Date.now(),
+            resourceId: 'res',
+            resourcePath: route.pattern,
+            authorizer: {},
+            protocol: 'HTTP/1.1',
+        },
+    };
+};
+const writeResult = (res, result) => {
+    const status = typeof result.statusCode === 'number' ? result.statusCode : 200;
+    const headers = result.headers ?? {};
+    const body = typeof result.body === 'string' ? result.body : '';
+    for (const [k, v] of Object.entries(headers)) {
+        if (typeof v === 'string')
+            res.setHeader(k, v);
+    }
+    res.statusCode = status;
+    res.end(body);
+};
+
+/**
+ * Load downstream registers to populate the app registry.
+ * Tries TS/JS candidates and logs which one was loaded when SMOZ_VERBOSE is set.
+ */
+const loadRegisters = async (root) => {
+    const candidates = [
+        path.resolve(root, 'app', 'generated', 'register.functions.ts'),
+        path.resolve(root, 'app', 'generated', 'register.functions.mts'),
+        path.resolve(root, 'app', 'generated', 'register.functions.js'),
+        path.resolve(root, 'app', 'generated', 'register.functions.mjs'),
+    ];
+    for (const p of candidates) {
+        try {
+            const url = pathToFileURL(p).href;
+            await import(url);
+            if (process.env.SMOZ_VERBOSE) {
+                const rel = path.relative(root, p).split(path.sep).join('/');
+                console.log('[inline] registers loaded:', rel);
+            }
+            return;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    console.warn('[inline] Could not load app/generated/register.functions.*. Run "npx smoz register" before inline dev.');
+};
+/**
+ * Load the App instance (TS source) from the downstream project.
+ * Returns only the surface needed by the inline server.
+ */
+const loadApp = async (root) => {
+    const p = path.resolve(root, 'app', 'config', 'app.config.ts');
+    const url = pathToFileURL(p).href;
+    const mod = (await import(url));
+    const app = mod.app;
+    if (!app || typeof app.buildAllServerlessFunctions !== 'function') {
+        throw new Error('Failed to load app/config/app.config.ts (missing export "app").');
+    }
+    return app;
+};
+
+const splitPattern = (p) => p
+    .replace(/\\/g, '/')
+    .replace(/^\/+|\/+$/g, '')
+    .split('/')
+    .filter(Boolean)
+    .map((s) => s.startsWith('{') && s.endsWith('}')
+    ? { key: s.slice(1, -1) }
+    : { literal: s });
+/**
+ * Build route table from the downstream app's aggregated serverless functions.
+ */
+const loadHandlers = async (root, app) => {
+    const fns = app.buildAllServerlessFunctions();
+    const routes = [];
+    for (const [, defUnknown] of Object.entries(fns)) {
+        const def = defUnknown;
+        if (typeof def.handler !== 'string' || !Array.isArray(def.events))
+            continue;
+        const [moduleRel, exportName] = (() => {
+            const lastDot = def.handler.lastIndexOf('.');
+            if (lastDot < 0)
+                return [def.handler, 'handler'];
+            return [
+                def.handler.slice(0, lastDot),
+                def.handler.slice(lastDot + 1),
+            ];
+        })();
+        // Resolve TS source module; dev runs via tsx so TS imports are OK
+        const candidates = [
+            path.resolve(root, `${moduleRel}.ts`),
+            path.resolve(root, `${moduleRel}.mts`),
+            path.resolve(root, `${moduleRel}.js`),
+            path.resolve(root, `${moduleRel}.mjs`),
+        ];
+        // Always try the first candidate (TS is expected in authoring).
+        const modUrl = pathToFileURL(candidates[0]).href;
+        const mod = (await import(modUrl));
+        const handler = mod[exportName];
+        if (typeof handler !== 'function')
+            continue;
+        for (const evt of def.events) {
+            const httpEvt = evt
+                .http;
+            const method = (httpEvt?.method ?? '').toUpperCase();
+            const pattern = '/' + (httpEvt?.path ?? '').replace(/^\/+/, '');
+            if (!method || !pattern)
+                continue;
+            routes.push({
+                method,
+                pattern,
+                segs: splitPattern(pattern),
+                handlerRef: `${moduleRel}.${exportName}`,
+                handler: handler,
+            });
+        }
+    }
+    return routes;
+};
+
+/**
+ * Inline HTTP dev server (module entry).
+ *
+ * Decomposed from the original single-file implementation to improve
+ * readability and maintainability:
+ * - loaders.ts: register/app loaders
+ * - routes.ts: route table construction
+ * - http.ts: request/event mapping helpers
+ */
+const start = async () => {
+    const root = process.cwd();
+    // Ensure register side-effects are loaded so the registry has routes
+    await loadRegisters(root);
+    // Load the App instance from the same TS source as the registers
+    const app = await loadApp(root);
+    const routes = await loadHandlers(root, app);
+    const portEnv = process.env.SMOZ_PORT;
+    const port = typeof portEnv === 'string' && portEnv.length > 0 ? Number(portEnv) : 0;
+    const server = http.createServer((req, res) => {
+        void (async () => {
+            try {
+                const method = (req.method ?? '').toUpperCase();
+                const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+                // Allow HEAD to match GET routes; the wrapped handler/middleware will
+                // short-circuit HEAD requests to 200 {} and set Content-Type.
+                const searchMethod = method === 'HEAD' ? 'GET' : method;
+                const route = routes.find((r) => r.method === searchMethod && match(r.segs, url.pathname).ok);
+                if (!route) {
+                    res.statusCode = 404;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: 'Not Found' }));
+                    return;
+                }
+                const { params } = match(route.segs, url.pathname);
+                const evt = await toEvent(req, route, params);
+                const result = await route.handler(evt, {
+                    awsRequestId: String(Date.now()),
+                    callbackWaitsForEmptyEventLoop: false,
+                    functionName: 'inline',
+                    functionVersion: '$LATEST',
+                    invokedFunctionArn: 'arn:inline',
+                    logGroupName: 'lg',
+                    logStreamName: 'ls',
+                    memoryLimitInMB: '256',
+                    getRemainingTimeInMillis: () => 30000,
+                    done: () => undefined,
+                    fail: () => undefined,
+                    succeed: () => undefined,
+                });
+                writeResult(res, result);
+            }
+            catch (e) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: e.message }));
+            }
+        })();
+    });
+    server.listen(port, () => {
+        const addr = server.address();
+        const resolved = typeof addr === 'object' && addr && 'port' in addr
+            ? addr.port
+            : port;
+        // Print route table
+        // Keep output consistent with existing tests:
+        // "[inline] listening on http://localhost:<port>"
+        console.log('[inline] listening on http://localhost:' + String(resolved));
+        const header = '[inline] routes:\n';
+        if (routes.length === 0) {
+            console.log(header + '  (none found)');
+        }
+        else {
+            const body = routes
+                .map((r) => '  ' +
+                r.method.padEnd(6) +
+                ' ' +
+                r.pattern +
+                '  ->  ' +
+                r.handlerRef)
+                .join('\n');
+            console.log(header + body);
+        }
+    });
+};
+// Start immediately when run via tsx
+void start();

package/package.json

@@ -31,9 +31,9 @@
   },
   "description": "John Galt Services back end.",
   "devDependencies": {
-    "@rollup/plugin-alias": "^5.1.1",
     "@dotenvx/dotenvx": "^1.49.0",
     "@eslint/js": "^9.35.0",
+    "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-typescript": "^12.1.4",
     "@serverless/typescript": "^4.18.2",
     "@types/aws-lambda": "^8.10.152",
@@ -49,7 +49,6 @@
     "fs-extra": "^11.3.1",
     "knip": "^5.63.1",
     "lefthook": "^1.13.0",
-    "pkg-dir": "^9.0.0",
     "prettier": "^3.6.2",
     "release-it": "^19.0.4",
     "rimraf": "^6.0.1",
@@ -182,5 +181,5 @@
     "templates:lint": "eslint --fix -c templates/default/eslint.config.ts \"templates/default/**/*.{ts,tsx,js,jsx}\" \"templates/default/eslint.config.ts\""
   },
   "type": "module",
-  "version": "0.2.4"
+  "version": "0.2.6"
 }

package/templates/default/app/config/openapi.ts

@@ -1,7 +1,6 @@
-import * as path from 'node:path';
-
-import * as fs from 'fs-extra';
+import fs from 'fs-extra';
 import { packageDirectorySync } from 'package-directory';
+import path from 'path';
 import { createDocument } from 'zod-openapi';
 
 import { app } from '@/app/config/app.config';
@@ -22,18 +21,20 @@ console.log('Generating OpenAPI document...');
 const paths = app.buildAllOpenApiPaths();
 export const doc = createDocument({
   openapi: '3.1.0',
-  servers: [{ description: 'Dev', url: 'http://localhost' }],
+  servers: [
+    { description: 'Production', url: 'https://api.example.test' },
+    { description: 'Dev', url: 'https://api.dev.example.test' },
+  ],
   info: {
-    title: process.env.npm_package_name ?? 'smoz-app',
-    version: process.env.npm_package_version ?? '0.0.0',
+    title: process.env.npm_package_name ?? '',
+    version: process.env.npm_package_version ?? '',
   },
   paths,
 });
 
 const pkgDir = packageDirectorySync();
-if (!pkgDir) {
-  throw new Error('Could not resolve package root directory');
-}
+if (!pkgDir) throw new Error('Could not find package root directory');
+
 const outDir = path.join(pkgDir, 'app', 'generated');
 fs.ensureDirSync(outDir);
 fs.writeFileSync(

package/templates/default/eslint.config.ts

@@ -9,6 +9,18 @@ import { fileURLToPath } from 'url';
 const tsconfigRootDir = dirname(fileURLToPath(import.meta.url));
 
 export default [
+  {
+    ignores: [
+      '.serverless/**',
+      '.stan/**',
+      '**/.tsbuild/**',
+      '**/generated/**',
+      'coverage/**',
+      'dist/**',
+      'docs/**',
+      'node_modules/**',
+    ],
+  },
   eslint.configs.recommended,
   ...tseslint.configs.strictTypeChecked,
   prettierConfig,

package/templates/default/package.json

@@ -5,9 +5,9 @@
   "version": "0.0.0",
   "dependencies": {
     "@middy/core": "^6.4.5",
-    "zod": "^4.1.6",
     "fs-extra": "^11.3.1",
-    "package-directory": "^8.1.0"
+    "package-directory": "^8.1.0",
+    "zod": "^4.1.6"
   },
   "devDependencies": {
     "@serverless/typescript": "^4.18.2",

package/templates/default/serverless.ts

@@ -107,9 +107,6 @@ const config: AWS = {
     versionFunctions: false,
   },
   functions: app.buildAllServerlessFunctions() as NonNullable<AWS['functions']>,
-  // Optional esbuild configuration (parity with /app fixture):
-  // These booleans are driven by global params in app.config.ts:
-  //   ESB_MINIFY, ESB_SOURCEMAP
   build: {
     esbuild: {
       bundle: true,

package/templates/default/tsconfig.downstream.json

@@ -7,12 +7,7 @@
     },
     "tsBuildInfoFile": ".tsbuild/tsconfig.tsbuildinfo"
   },
-  "exclude": [
-    ".serverless/**",
-    "node_modules/**",
-    "app/generated/**",
-    "dist/**"
-  ],
+  "exclude": [".serverless/**", "node_modules/**", "app/generated/**"],
   "extends": "./tsconfig.base.json",
   "include": ["**/*", "**/*.json"]
 }