@karmaniverous/smoz 0.1.3 → 0.1.5

package/dist/cli/index.cjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 'use strict';
 
 var fs = require('node:fs');
@@ -11,6 +10,7 @@ var chokidar = require('chokidar');
 var node_child_process = require('node:child_process');
 var os = require('node:os');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 /**
  * SMOZ CLI: add
  *
@@ -823,8 +823,12 @@ const walk = async (dir, out = []) => {
     return out;
 };
 const resolveTemplatesBase = () => {
-    // Resolve the package root (works both in dev and when installed)
-    const pkgRoot = packageDirectory.packageDirectorySync() ?? process.cwd();
+    // Resolve the templates folder from the CLI package install root,
+    // not the caller’s project root. This makes --template <name> work
+    // consistently whether smoz is run from a consuming app or this repo.
+    // Anchor discovery to this module’s directory.
+    const here = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+    const pkgRoot = packageDirectory.packageDirectorySync({ cwd: here }) ?? process.cwd(); // conservative fallback
     return path.resolve(pkgRoot, 'templates');
 };
 const readJson = async (file) => {
@@ -1044,8 +1048,7 @@ const runInit = async (root, template = 'minimal', opts) => {
 /**
  * SMOZ CLI — version/signature + register/add
  *
- * - Default: print project signature (version, Node, repo root, stanPath, config presence)
- * - register: one-shot — generate app/generated/register.*.ts from app/functions/**
+ * - Default: print project signature (version, Node, repo root, stanPath, config presence) * - register: one-shot — generate app/generated/register.*.ts from app/functions/**
  * - openapi: one-shot — run the project’s OpenAPI builder
  * - dev: watch loop orchestrator for register/openapi and optional local serving
  * - add: scaffold a new function skeleton under app/functions

package/package.json

@@ -185,5 +185,5 @@
     "templates:lint": "eslint --fix -c templates/.check/eslint.templates.config.ts \"templates/**/*.{ts,tsx,js,jsx}\" && eslint --fix --no-ignore templates/.check/eslint.templates.config.ts"
   },
   "type": "module",
-  "version": "0.1.3"
+  "version": "0.1.5"
 }

package/templates/.manifests/package.full.json

@@ -0,0 +1,21 @@
+{
+  "dependencies": {
+    "zod": "^4.1.5",
+    "@middy/core": "^6.4.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.41.0",
+    "eslint": "^9.34.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "vitest": "^3.2.4",
+    "typedoc": "^0.28.11"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
+  }
+}

package/templates/full/app/config/app.config.ts

@@ -0,0 +1,50 @@
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { App, baseEventTypeMapSchema, toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+// Derive the app root as the parent directory of app/config/
+export const APP_ROOT_ABS = toPosixPath(
+  fileURLToPath(new URL('..', import.meta.url)),
+);
+
+export const app = App.create({
+  appRootAbs: APP_ROOT_ABS,
+  globalParamsSchema: z.object({
+    PROFILE: z.string(),
+    REGION: z.string(),
+    SERVICE_NAME: z.string(),
+  }),
+  stageParamsSchema: z.object({
+    STAGE: z.string(),
+  }),
+  eventTypeMapSchema: baseEventTypeMapSchema,
+  serverless: {
+    httpContextEventMap: {
+      my: {}, // place a Cognito authorizer here if needed
+      private: { private: true },
+      public: {},
+    },
+    defaultHandlerFileName: 'handler',
+    defaultHandlerFileExport: 'handler',
+  },
+  global: {
+    params: {
+      PROFILE: 'dev',
+      REGION: 'us-east-1',
+      SERVICE_NAME: 'my-smoz-app',
+    },
+    envKeys: ['REGION', 'SERVICE_NAME'] as const,
+  },
+  stage: {
+    params: {
+      dev: { STAGE: 'dev' },
+    },
+    envKeys: ['STAGE'] as const,
+  },
+});
+
+export const ENDPOINTS_ROOT_REST = toPosixPath(
+  join(APP_ROOT_ABS, 'functions', 'rest'),
+);

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

@@ -0,0 +1,44 @@
+import * as path from 'node:path';
+
+import * as fs from 'fs-extra';
+import { packageDirectorySync } from 'pkg-dir';
+import { createDocument } from 'zod-openapi';
+
+import { app } from '@/app/config/app.config';
+/**
+ * Template note:
+ * - Templates do NOT commit generated register files under app/generated; they
+ *   are declared via ambient types so TypeScript can typecheck without artifacts.
+ * - To ensure side effects still run (endpoint registration) and to satisfy
+ *   noUncheckedSideEffectImports, import the register module as a namespace and
+ *   reference it via `void`.
+ * - In real apps, `smoz init` seeds placeholders and `smoz register` rewrites
+ *   app/generated/register.*.ts at author time.
+ */
+import * as __register_openapi from '@/app/generated/register.openapi';
+void __register_openapi;
+console.log('Generating OpenAPI document...');
+
+const paths = app.buildAllOpenApiPaths();
+export const doc = createDocument({
+  openapi: '3.1.0',
+  servers: [{ description: 'Dev', url: 'http://localhost' }],
+  info: {
+    title: process.env.npm_package_name ?? 'smoz-app',
+    version: process.env.npm_package_version ?? '0.0.0',
+  },
+  paths,
+});
+
+const pkgDir = packageDirectorySync();
+if (!pkgDir) {
+  throw new Error('Could not resolve package root directory');
+}
+const outDir = path.join(pkgDir, 'app', 'generated');
+fs.ensureDirSync(outDir);
+fs.writeFileSync(
+  path.join(outDir, 'openapi.json'),
+  JSON.stringify(doc, null, 2),
+);
+
+console.log('Done!');

package/templates/full/app/functions/rest/hello/get/handler.ts

@@ -0,0 +1,18 @@
+import type { z } from 'zod';
+
+import type { responseSchema } from './lambda';
+import { fn } from './lambda';
+
+type Response = z.infer<typeof responseSchema>;
+
+type FnHandlerApi<T> = {
+  handler: (impl: () => Promise<T> | T) => (...args: unknown[]) => Promise<T>;
+};
+
+const reg = fn as unknown as FnHandlerApi<Response>;
+
+export const handler = reg.handler(async () => {
+  const res: Response = { ok: true };
+  await Promise.resolve(); // satisfy require-await without adding complexity
+  return res;
+});

package/templates/full/app/functions/rest/hello/get/lambda.ts

@@ -0,0 +1,28 @@
+import { join } from 'node:path';
+
+import { toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+import { app, APP_ROOT_ABS } from '@/app/config/app.config';
+
+export const eventSchema = z.object({}).optional();
+export const responseSchema = z.object({ ok: z.boolean() });
+type FnApi = {
+  handler: <T>(
+    impl: () => Promise<T> | T,
+  ) => (...args: unknown[]) => Promise<T>;
+  openapi: (op: unknown) => void;
+};
+
+export const fn = app.defineFunction({
+  functionName: 'hello_get',
+  eventType: 'rest',
+  httpContexts: ['public'],
+  method: 'get',
+  basePath: 'hello',
+  contentType: 'application/json',
+  eventSchema,
+  responseSchema,
+  callerModuleUrl: import.meta.url,
+  endpointsRootAbs: toPosixPath(join(APP_ROOT_ABS, 'functions', 'rest')),
+}) as unknown as FnApi;

package/templates/full/app/functions/rest/hello/get/openapi.ts

@@ -0,0 +1,19 @@
+import { fn, responseSchema } from './lambda';
+
+type FnOpenApiApi = {
+  openapi: (op: unknown) => void;
+};
+
+const reg = fn as unknown as FnOpenApiApi;
+
+reg.openapi({
+  summary: 'Hello',
+  description: 'Return a simple OK payload.',
+  responses: {
+    200: {
+      description: 'Ok',
+      content: { 'application/json': { schema: responseSchema } },
+    },
+  },
+  tags: ['public'],
+});

package/templates/full/app/functions/rest/openapi/get/handler.ts

@@ -0,0 +1,20 @@
+import type { z } from 'zod';
+
+import openapiDoc from '@/app/generated/openapi.json';
+
+import type { responseSchema } from './lambda';
+import { fn } from './lambda';
+
+type Response = z.infer<typeof responseSchema>;
+
+type FnHandlerApi<T> = {
+  handler: (impl: () => Promise<T> | T) => (...args: unknown[]) => Promise<T>;
+};
+
+const reg = fn as unknown as FnHandlerApi<Response>;
+
+export const handler = reg.handler(async () => {
+  // Trivial await to mirror minimal template style
+  await Promise.resolve();
+  return openapiDoc as Response;
+});

package/templates/full/app/functions/rest/openapi/get/lambda.ts

@@ -0,0 +1,29 @@
+import { join } from 'node:path';
+
+import { toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+import { app, APP_ROOT_ABS } from '@/app/config/app.config';
+
+export const eventSchema = z.any().optional();
+export const responseSchema = z.unknown();
+
+type FnApi = {
+  handler: <T>(
+    impl: () => Promise<T> | T,
+  ) => (...args: unknown[]) => Promise<T>;
+  openapi: (op: unknown) => void;
+};
+
+export const fn = app.defineFunction({
+  functionName: 'openapi_get',
+  eventType: 'rest',
+  httpContexts: ['public'],
+  method: 'get',
+  basePath: 'openapi',
+  contentType: 'application/json',
+  eventSchema,
+  responseSchema,
+  callerModuleUrl: import.meta.url,
+  endpointsRootAbs: toPosixPath(join(APP_ROOT_ABS, 'functions', 'rest')),
+}) as unknown as FnApi;

package/templates/full/app/functions/rest/openapi/get/openapi.ts

@@ -0,0 +1,20 @@
+import { fn, responseSchema } from './lambda';
+
+type FnOpenApiApi = {
+  openapi: (op: unknown) => void;
+};
+
+const reg = fn as unknown as FnOpenApiApi;
+
+reg.openapi({
+  summary: 'Get OpenAPI document',
+  description:
+    'Return the OpenAPI 3.1 document. Generate it via "npm run openapi".',
+  responses: {
+    200: {
+      description: 'OpenAPI document',
+      content: { 'application/json': { schema: responseSchema } },
+    },
+  },
+  tags: ['openapi'],
+});

package/templates/full/app/functions/sqs/tick/handler.ts

@@ -0,0 +1,7 @@
+import { fn } from './lambda';
+
+export const handler = fn.handler((event) => {
+  // process SQS batch event
+  void event;
+  // no response payload (void)
+});

package/templates/full/app/functions/sqs/tick/lambda.ts

@@ -0,0 +1,24 @@
+import { join } from 'node:path';
+
+import { toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+import { app, APP_ROOT_ABS } from '@/app/config/app.config';
+
+export const eventSchema = z.any();
+export const responseSchema = z.void();
+
+type FnApi = {
+  handler: <T>(
+    impl: (e: unknown) => Promise<T> | T,
+  ) => (...args: unknown[]) => Promise<T>;
+  serverless: (extras: unknown) => void;
+};
+
+export const fn = app.defineFunction({
+  eventType: 'sqs',
+  eventSchema,
+  responseSchema,
+  callerModuleUrl: import.meta.url,
+  endpointsRootAbs: toPosixPath(join(APP_ROOT_ABS, 'functions', 'sqs')),
+}) as unknown as FnApi;

package/templates/full/app/functions/sqs/tick/serverless.ts

@@ -0,0 +1,8 @@
+import { fn } from './lambda';
+
+// Attach SQS trigger (replace ARN with your queue)
+fn.serverless([
+  {
+    sqs: { arn: 'arn:aws:sqs:us-east-1:000000000000:my-queue' },
+  },
+]);

package/templates/full/app/generated/openapi.json

@@ -0,0 +1,8 @@
+{
+  "openapi": "3.1.0",
+  "info": { "title": "smoz-app", "version": "0.0.0" },
+  "servers": [
+    { "description": "Dev", "url": "http://localhost" }
+  ],
+  "paths": {}
+}

package/templates/full/serverless.ts

@@ -0,0 +1,33 @@
+import type { AWS } from '@serverless/typescript';
+
+import { app } from '@/app/config/app.config';
+/**
+ * Template note:
+ * - Templates do NOT commit generated register files under app/generated; they
+ *   are declared via ambient types so TypeScript can typecheck without artifacts.
+ * - To ensure side effects still run (endpoint/serverless registration) and to
+ *   satisfy noUncheckedSideEffectImports, import register modules as namespaces
+ *   and reference them via `void`.
+ * - In real apps, `smoz init` seeds placeholders and `smoz register` rewrites
+ *   app/generated/register.*.ts at author time.
+ */
+import * as __register_functions from '@/app/generated/register.functions';
+import * as __register_serverless from '@/app/generated/register.serverless';
+void __register_functions;
+void __register_serverless;
+
+const config: AWS = {
+  service: '${param:SERVICE_NAME}',
+  frameworkVersion: '4',
+  stages: app.stages as NonNullable<AWS['stages']>,
+  provider: {
+    name: 'aws',
+    region: '${param:REGION}' as NonNullable<AWS['provider']['region']>,
+    runtime: 'nodejs22.x',
+    environment: app.environment as NonNullable<AWS['provider']['environment']>,
+    stage: '${opt:stage, "dev"}',
+  },
+  functions: app.buildAllServerlessFunctions() as NonNullable<AWS['functions']>,
+};
+
+export default config;

package/templates/full/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": ".",
+    "outDir": ".tsbuild",
+    "paths": {
+      "@/*": ["*"],
+      "@karmaniverous/smoz": ["../../.stan/dist/index.d.ts"]
+    },
+    "typeRoots": ["../../node_modules/@types", "./node_modules/@types"],
+    "tsBuildInfoFile": ".tsbuild/tsconfig.tsbuildinfo"
+  },
+  "exclude": [
+    ".serverless/**",
+    "node_modules/**",
+    "app/generated/**",
+    "dist/**"
+  ],
+  "extends": "../project/tsconfig.base.json",
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.d.ts"
+  ]
+}

package/templates/full/types/registers.d.ts

@@ -0,0 +1,11 @@
+// Ambient declarations to satisfy template typechecking without requiring
+// generated register files to exist on disk.
+declare module '@/app/generated/register.functions' {
+  export {};
+}
+declare module '@/app/generated/register.openapi' {
+  export {};
+}
+declare module '@/app/generated/register.serverless' {
+  export {};
+}

package/templates/minimal/app/functions/rest/openapi/get/handler.ts

@@ -0,0 +1,22 @@
+import type { z } from 'zod';
+
+// Import the document from its real generated location.
+// The template ships a placeholder at app/generated/openapi.json.
+import openapiDoc from '@/app/generated/openapi.json';
+
+import type { responseSchema } from './lambda';
+import { fn } from './lambda';
+
+type Response = z.infer<typeof responseSchema>;
+type FnHandlerApi<T> = {
+  handler: (impl: () => Promise<T> | T) => (...args: unknown[]) => Promise<T>;
+};
+
+const reg = fn as unknown as FnHandlerApi<Response>;
+
+export const handler = reg.handler(async () => {
+  // Tip: run `npm run openapi` to regenerate this file.
+  // Trivial await keeps parity with prior style.
+  await Promise.resolve();
+  return openapiDoc as Response;
+});

package/templates/minimal/app/functions/rest/openapi/get/lambda.ts

@@ -0,0 +1,29 @@
+import { join } from 'node:path';
+
+import { toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+import { app, APP_ROOT_ABS } from '@/app/config/app.config';
+
+export const eventSchema = z.any().optional();
+export const responseSchema = z.unknown();
+
+type FnApi = {
+  handler: <T>(
+    impl: () => Promise<T> | T,
+  ) => (...args: unknown[]) => Promise<T>;
+  openapi: (op: unknown) => void;
+};
+
+export const fn = app.defineFunction({
+  functionName: 'openapi_get',
+  eventType: 'rest',
+  httpContexts: ['public'],
+  method: 'get',
+  basePath: 'openapi',
+  contentType: 'application/json',
+  eventSchema,
+  responseSchema,
+  callerModuleUrl: import.meta.url,
+  endpointsRootAbs: toPosixPath(join(APP_ROOT_ABS, 'functions', 'rest')),
+}) as unknown as FnApi;

package/templates/minimal/app/functions/rest/openapi/get/openapi.ts

@@ -0,0 +1,20 @@
+import { fn, responseSchema } from './lambda';
+
+type FnOpenApiApi = {
+  openapi: (op: unknown) => void;
+};
+
+const reg = fn as unknown as FnOpenApiApi;
+
+reg.openapi({
+  summary: 'Get OpenAPI document',
+  description:
+    'Return the OpenAPI 3.1 document. Generate it via "npm run openapi".',
+  responses: {
+    200: {
+      description: 'OpenAPI document',
+      content: { 'application/json': { schema: responseSchema } },
+    },
+  },
+  tags: ['openapi'],
+});

package/templates/minimal/app/generated/openapi.json

@@ -0,0 +1,8 @@
+{
+  "openapi": "3.1.0",
+  "info": { "title": "smoz-app", "version": "0.0.0" },
+  "servers": [
+    { "description": "Dev", "url": "http://localhost" }
+  ],
+  "paths": {}
+}