create-loutre 0.1.0

package/bin/create-loutre.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runCreateLoutre } from '../dist/cli.js'
+
+process.exitCode = await runCreateLoutre(process.argv.slice(2))

package/dist/app.d.ts

@@ -0,0 +1,20 @@
+import type { PackageManager, ProjectTarget } from './options.js';
+export interface CreateProjectInput {
+    readonly cwd: string;
+    readonly directory: string;
+    readonly packageManager: PackageManager;
+    readonly target: ProjectTarget;
+}
+export interface CreateProjectResult {
+    readonly packageName: string;
+    readonly targetDirectory: string;
+}
+export declare class ProjectScaffolder {
+    create(input: CreateProjectInput): Promise<CreateProjectResult>;
+}
+export declare const createProject: import("@loutrejs/loutre").TaskDescriptor<CreateProjectInput, CreateProjectResult, string>;
+declare const _default: import("@loutrejs/loutre").ApplicationDefinition<readonly [import("@loutrejs/loutre").ModuleInstance<{
+    readonly name: "CreateLoutreModule";
+    readonly providers: readonly [typeof ProjectScaffolder];
+}>], undefined, readonly [import("@loutrejs/loutre").TaskDescriptor<CreateProjectInput, CreateProjectResult, string>], readonly []>;
+export default _default;

package/dist/app.js

@@ -0,0 +1,62 @@
+import { readdir } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { defineApplication, defineModule, inject, task } from '@loutrejs/loutre';
+import { writeStarter } from './starter.js';
+export class ProjectScaffolder {
+    async create(input) {
+        const targetDirectory = resolve(input.cwd, input.directory);
+        const packageName = packageNameFor(targetDirectory);
+        await assertTargetIsEmpty(targetDirectory);
+        await writeStarter(targetDirectory, {
+            packageName,
+            packageManager: input.packageManager,
+            target: input.target,
+        });
+        return { packageName, targetDirectory };
+    }
+}
+export const createProject = task({
+    name: 'project.create',
+    factory: (scaffolder = inject(ProjectScaffolder)) => (input) => scaffolder.create(input),
+});
+const CreateLoutreModule = defineModule(() => ({
+    name: 'CreateLoutreModule',
+    providers: [ProjectScaffolder],
+}));
+export default defineApplication({
+    modules: [CreateLoutreModule()],
+    tasks: [createProject],
+});
+async function assertTargetIsEmpty(targetDirectory) {
+    try {
+        const entries = await readdir(targetDirectory);
+        if (entries.length > 0) {
+            throw new Error(`生成先が空ではありません: ${targetDirectory}`);
+        }
+    }
+    catch (error) {
+        if (isMissingDirectory(error))
+            return;
+        throw error;
+    }
+}
+function isMissingDirectory(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+function packageNameFor(targetDirectory) {
+    const name = basename(targetDirectory)
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/gu, '-')
+        .replace(/[^a-z0-9._-]+/gu, '-')
+        .replace(/^-+|-+$/gu, '');
+    if (name.length === 0 ||
+        name.length > 214 ||
+        name.startsWith('.') ||
+        name.startsWith('_')) {
+        throw new Error(`npm package名を生成できません: ${targetDirectory}`);
+    }
+    return name;
+}

package/dist/cli.d.ts

@@ -0,0 +1,16 @@
+import { type PackageManager } from './options.js';
+interface SelectOption {
+    readonly value: string;
+    readonly label: string;
+}
+export interface CreateLoutreCliIO {
+    readonly cwd: string;
+    readonly detectedPackageManager?: PackageManager;
+    readonly prompt?: (message: string, initialValue: string) => Promise<string | undefined>;
+    readonly select?: (message: string, options: readonly SelectOption[], initialValue: string) => Promise<string | undefined>;
+    readonly install: (directory: string, packageManager: PackageManager) => Promise<number>;
+    readonly stdout: (value: string) => void;
+    readonly stderr: (value: string) => void;
+}
+export declare function runCreateLoutre(args: readonly string[], io?: CreateLoutreCliIO): Promise<number>;
+export {};

package/dist/cli.js

@@ -0,0 +1,208 @@
+import { spawn } from 'node:child_process';
+import { relative } from 'node:path';
+import { isCancel, select, text } from '@clack/prompts';
+import { Command, CommanderError, Option } from 'commander';
+import { bootstrap } from '@loutrejs/loutre/host';
+import application, { createProject } from './app.js';
+import { installCommand, packageManagerLabels, packageManagers, projectTargets, runScriptCommand, targetLabels, } from './options.js';
+export async function runCreateLoutre(args, io = createProcessIO()) {
+    const parsed = parseArgs(args);
+    if ('error' in parsed) {
+        io.stderr(parsed.error);
+        io.stderr(helpText());
+        return 2;
+    }
+    if (parsed.help) {
+        io.stdout(helpText());
+        return 0;
+    }
+    const directory = await resolveDirectory(parsed.directory, parsed.yes, io);
+    if (!directory)
+        return 2;
+    const target = await resolveTarget(parsed.target, parsed.yes, io);
+    if (!target)
+        return 2;
+    const packageManager = await resolvePackageManager(parsed.packageManager, parsed.yes, io);
+    if (!packageManager)
+        return 2;
+    const app = bootstrap({ application });
+    try {
+        const result = await app.run(createProject, {
+            cwd: io.cwd,
+            directory,
+            packageManager,
+            target,
+        });
+        io.stdout(`Loutre Applicationを作成しました: ${result.targetDirectory}`);
+        io.stdout(`Target: ${targetLabels[target]}`);
+        io.stdout(`Package manager: ${packageManagerLabels[packageManager]}`);
+        if (parsed.install) {
+            io.stdout('依存関係をインストールします。');
+            const installCode = await io.install(result.targetDirectory, packageManager);
+            if (installCode !== 0) {
+                io.stderr(`${installCommand(packageManager)}に失敗しました。生成したファイルは残しています。`);
+                return installCode;
+            }
+        }
+        const nextDirectory = relative(io.cwd, result.targetDirectory);
+        io.stdout('');
+        io.stdout('次のコマンド:');
+        if (nextDirectory && nextDirectory !== '.') {
+            io.stdout(`  cd ${quoteShellArgument(nextDirectory)}`);
+        }
+        if (!parsed.install)
+            io.stdout(`  ${installCommand(packageManager)}`);
+        io.stdout(`  ${nextCommand(packageManager, target)}`);
+        return 0;
+    }
+    catch (error) {
+        io.stderr(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    finally {
+        await app.close('create-loutre-complete');
+    }
+}
+function parseArgs(args) {
+    const command = new Command()
+        .name('create-loutre')
+        .helpOption(false)
+        .exitOverride()
+        .configureOutput({
+        writeOut: () => undefined,
+        writeErr: () => undefined,
+    })
+        .argument('[directory]')
+        .addOption(new Option('--target <target>').choices([...projectTargets]))
+        .addOption(new Option('--package-manager <package-manager>').choices([
+        ...packageManagers,
+    ]))
+        .option('-y, --yes', '未指定の選択肢に既定値を使用する')
+        .option('--no-install', '依存関係をinstallしない')
+        .option('-h, --help', 'helpを表示する')
+        .allowExcessArguments(false);
+    try {
+        command.parse(args.filter((value) => value !== '--'), { from: 'user' });
+    }
+    catch (error) {
+        if (error instanceof CommanderError)
+            return { error: error.message };
+        throw error;
+    }
+    const options = command.opts();
+    const directory = command.processedArgs[0];
+    return {
+        ...(directory === undefined ? {} : { directory }),
+        ...(options.target === undefined ? {} : { target: options.target }),
+        ...(options.packageManager === undefined
+            ? {}
+            : { packageManager: options.packageManager }),
+        help: options.help ?? false,
+        yes: options.yes ?? false,
+        install: options.install,
+    };
+}
+async function resolveDirectory(requested, yes, io) {
+    if (requested)
+        return requested;
+    if (yes)
+        return 'loutre-app';
+    if (!io.prompt) {
+        io.stderr('生成先を指定してください。例: npm create loutre@latest my-app');
+        return undefined;
+    }
+    const answer = await io.prompt('Project name', 'loutre-app');
+    if (answer === undefined)
+        return undefined;
+    return answer.trim() || 'loutre-app';
+}
+async function resolveTarget(requested, yes, io) {
+    if (requested)
+        return requested;
+    if (yes || !io.select)
+        return 'node';
+    const selected = await io.select('Target', projectTargets.map((value) => ({ value, label: targetLabels[value] })), 'node');
+    return projectTargets.find((target) => target === selected);
+}
+async function resolvePackageManager(requested, yes, io) {
+    if (requested)
+        return requested;
+    const initialValue = io.detectedPackageManager ?? 'npm';
+    if (yes || !io.select)
+        return initialValue;
+    const selected = await io.select('Package manager', packageManagers.map((value) => ({
+        value,
+        label: packageManagerLabels[value],
+    })), initialValue);
+    return packageManagers.find((packageManager) => packageManager === selected);
+}
+function createProcessIO() {
+    const interactive = process.stdin.isTTY && process.stdout.isTTY;
+    return {
+        cwd: process.cwd(),
+        detectedPackageManager: detectPackageManager(process.env.npm_config_user_agent, globalThis),
+        ...(interactive ? { prompt: terminalPrompt, select: terminalSelect } : {}),
+        install: installDependencies,
+        stdout: (value) => process.stdout.write(`${value}\n`),
+        stderr: (value) => process.stderr.write(`${value}\n`),
+    };
+}
+async function terminalPrompt(message, initialValue) {
+    const result = await text({ message, defaultValue: initialValue });
+    return isCancel(result) ? undefined : result;
+}
+async function terminalSelect(message, options, initialValue) {
+    const result = await select({ message, options: [...options], initialValue });
+    return isCancel(result) ? undefined : result;
+}
+function installDependencies(directory, packageManager) {
+    const command = executableFor(packageManager);
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(command, ['install'], {
+            cwd: directory,
+            stdio: 'inherit',
+        });
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+            resolvePromise(code ?? (signal ? 1 : 0));
+        });
+    });
+}
+function executableFor(packageManager) {
+    if (process.platform !== 'win32')
+        return packageManager;
+    return packageManager === 'npm' ||
+        packageManager === 'pnpm' ||
+        packageManager === 'yarn'
+        ? `${packageManager}.cmd`
+        : packageManager;
+}
+function detectPackageManager(userAgent, runtime) {
+    const globals = runtime;
+    if (globals.Bun !== undefined)
+        return 'bun';
+    if (globals.Deno !== undefined)
+        return 'deno';
+    const name = userAgent?.split('/')[0];
+    return (packageManagers.find((packageManager) => packageManager === name) ?? 'npm');
+}
+function nextCommand(packageManager, target) {
+    return runScriptCommand(packageManager, target === 'aws-lambda' ? 'build' : 'dev');
+}
+function quoteShellArgument(value) {
+    return /^[A-Za-z0-9_./-]+$/u.test(value)
+        ? value
+        : `'${value.replaceAll("'", "'\\''")}'`;
+}
+function helpText() {
+    return [
+        'Usage: create-loutre [directory] [options]',
+        '',
+        'Options:',
+        '  --target <target>                    node | bun | deno | cloudflare-workers | aws-lambda',
+        '  --package-manager <package-manager>  npm | pnpm | yarn | bun | deno',
+        '  -y, --yes                            未指定の選択肢に既定値を使用する',
+        '  --no-install                         依存関係をinstallしない',
+        '  -h, --help                           helpを表示する',
+    ].join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createProject, ProjectScaffolder, type CreateProjectInput, type CreateProjectResult, } from './app.js';
+export { runCreateLoutre, type CreateLoutreCliIO } from './cli.js';
+export { packageManagers, projectTargets, type PackageManager, type ProjectTarget, } from './options.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createProject, ProjectScaffolder, } from './app.js';
+export { runCreateLoutre } from './cli.js';
+export { packageManagers, projectTargets, } from './options.js';

package/dist/options.d.ts

@@ -0,0 +1,8 @@
+export declare const projectTargets: readonly ['node', 'bun', 'deno', 'cloudflare-workers', 'aws-lambda'];
+export type ProjectTarget = (typeof projectTargets)[number];
+export declare const packageManagers: readonly ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
+export type PackageManager = (typeof packageManagers)[number];
+export declare const targetLabels: Readonly<Record<ProjectTarget, string>>;
+export declare const packageManagerLabels: Readonly<Record<PackageManager, string>>;
+export declare function installCommand(packageManager: PackageManager): string;
+export declare function runScriptCommand(packageManager: PackageManager, script: string): string;

package/dist/options.js

@@ -0,0 +1,39 @@
+export const projectTargets = [
+    'node',
+    'bun',
+    'deno',
+    'cloudflare-workers',
+    'aws-lambda',
+];
+export const packageManagers = ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
+export const targetLabels = {
+    node: 'Node.js',
+    bun: 'Bun',
+    deno: 'Deno',
+    'cloudflare-workers': 'Cloudflare Workers',
+    'aws-lambda': 'AWS Lambda',
+};
+export const packageManagerLabels = {
+    npm: 'npm',
+    pnpm: 'pnpm',
+    yarn: 'Yarn',
+    bun: 'Bun',
+    deno: 'Deno',
+};
+export function installCommand(packageManager) {
+    return `${packageManager} install`;
+}
+export function runScriptCommand(packageManager, script) {
+    switch (packageManager) {
+        case 'npm':
+            return `npm run ${script}`;
+        case 'pnpm':
+            return `pnpm run ${script}`;
+        case 'yarn':
+            return `yarn run ${script}`;
+        case 'bun':
+            return `bun run ${script}`;
+        case 'deno':
+            return `deno task ${script}`;
+    }
+}

package/dist/starter.d.ts

@@ -0,0 +1,7 @@
+import { type PackageManager, type ProjectTarget } from './options.js';
+export interface StarterOptions {
+    readonly packageName: string;
+    readonly packageManager: PackageManager;
+    readonly target: ProjectTarget;
+}
+export declare function writeStarter(targetDirectory: string, options: StarterOptions): Promise<void>;

package/dist/starter.js

@@ -0,0 +1,208 @@
+import { readFileSync } from 'node:fs';
+import { cp, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runScriptCommand, targetLabels, } from './options.js';
+const packageManifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const loutreVersion = requiredDependencyVersion('@loutrejs/loutre');
+function requiredDependencyVersion(name) {
+    const version = packageManifest.dependencies[name];
+    if (!version)
+        throw new Error(`${name}のversionがpackage.jsonにありません。`);
+    return version;
+}
+const baseTemplateDirectory = fileURLToPath(new URL('../templates/base/', import.meta.url));
+const targetsTemplateDirectory = fileURLToPath(new URL('../templates/targets/', import.meta.url));
+const renamedTemplateFiles = new Map([
+    ['_gitignore', '.gitignore'],
+    ['_oxlintrc.json', '.oxlintrc.json'],
+    ['_oxfmtrc.json', '.oxfmtrc.json'],
+]);
+export async function writeStarter(targetDirectory, options) {
+    await cp(baseTemplateDirectory, targetDirectory, { recursive: true });
+    await cp(join(targetsTemplateDirectory, options.target), targetDirectory, {
+        recursive: true,
+    });
+    for (const [source, destination] of renamedTemplateFiles) {
+        await rename(join(targetDirectory, source), join(targetDirectory, destination));
+    }
+    await writeFile(join(targetDirectory, 'package.json'), renderPackageJson(options), 'utf8');
+    await replaceText(join(targetDirectory, 'tsconfig.json'), '"__LOUTRE_TYPES__"', JSON.stringify(targetManifest(options.target).types));
+    await renderTextTemplate(join(targetDirectory, 'README.md'), {
+        targetLabel: targetLabels[options.target],
+        developmentSection: developmentSection(options),
+        verifyCommand: runScriptCommand(options.packageManager, 'verify'),
+        deploymentSection: deploymentSection(options),
+    });
+    if (options.target === 'cloudflare-workers') {
+        await renderTextTemplate(join(targetDirectory, 'wrangler.jsonc'), {
+            packageName: workerNameFor(options.packageName),
+            compatibilityDate: new Date().toISOString().slice(0, 10),
+        });
+    }
+}
+function targetManifest(target) {
+    switch (target) {
+        case 'node':
+            return {
+                scripts: {
+                    dev: 'tsx watch src/main.ts',
+                    build: 'tsc -p tsconfig.build.json',
+                    start: 'node dist/main.js',
+                },
+                dependencies: { '@loutrejs/node': loutreVersion },
+                devDependencies: { '@types/node': '^22.20.1', tsx: '^4.23.12' },
+                engines: { node: '>=22' },
+                types: ['node'],
+            };
+        case 'bun':
+            return {
+                scripts: {
+                    dev: 'bun --watch src/main.ts',
+                    build: 'bun build src/main.ts --outdir dist --target bun',
+                    start: 'bun dist/main.js',
+                },
+                devDependencies: { '@types/bun': '^1.4.0' },
+                types: ['bun'],
+            };
+        case 'deno':
+            return {
+                scripts: {
+                    dev: 'deno run -A --watch src/main.ts',
+                    start: 'deno run -A src/main.ts',
+                },
+                typecheck: 'tsc --noEmit --allowImportingTsExtensions',
+                types: [],
+            };
+        case 'cloudflare-workers':
+            return {
+                scripts: {
+                    dev: 'wrangler dev',
+                    build: 'wrangler deploy --dry-run --outdir dist',
+                    deploy: 'wrangler deploy',
+                },
+                devDependencies: { wrangler: '^4.127.1' },
+                types: [],
+            };
+        case 'aws-lambda':
+            return {
+                scripts: {
+                    build: 'esbuild src/main.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.mjs',
+                },
+                devDependencies: { '@types/node': '^22.20.1', esbuild: '^0.28.2' },
+                engines: { node: '>=22' },
+                types: ['node'],
+            };
+    }
+}
+function renderPackageJson(options) {
+    const target = targetManifest(options.target);
+    const build = target.scripts.build;
+    const typecheck = target.typecheck ?? 'tsc --noEmit';
+    const verifyBuild = build === undefined ? '' : ` && ${build}`;
+    return `${JSON.stringify({
+        name: options.packageName,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        ...(target.engines === undefined ? {} : { engines: target.engines }),
+        scripts: {
+            ...target.scripts,
+            typecheck,
+            check: `${typecheck} && loutre check --entry src/app.ts`,
+            test: 'vitest run',
+            'test:watch': 'vitest',
+            lint: 'oxlint',
+            'lint:fix': 'oxlint --fix',
+            format: 'oxfmt',
+            'format:check': 'oxfmt --check',
+            verify: `oxfmt --check && oxlint && ${typecheck} && loutre check --entry src/app.ts && vitest run${verifyBuild}`,
+        },
+        dependencies: {
+            '@loutrejs/loutre': loutreVersion,
+            zod: '^4.4.3',
+            ...target.dependencies,
+        },
+        devDependencies: {
+            '@loutrejs/cli': loutreVersion,
+            oxfmt: '^0.65.0',
+            oxlint: '^1.80.0',
+            typescript: '^7.0.2',
+            vitest: '^4.1.11',
+            ...target.devDependencies,
+        },
+    }, null, 2)}\n`;
+}
+function developmentSection(options) {
+    if (options.target === 'aws-lambda') {
+        return [
+            '## 開発',
+            '',
+            'Lambda targetはlocal HTTP listenerを起動しません。Applicationの挙動はtestで確認します。',
+            '',
+            '```sh',
+            runScriptCommand(options.packageManager, 'test:watch'),
+            '```',
+        ].join('\n');
+    }
+    return [
+        '## 開発',
+        '',
+        '```sh',
+        runScriptCommand(options.packageManager, 'dev'),
+        '```',
+        '',
+        options.target === 'cloudflare-workers'
+            ? 'WranglerがlocalのCloudflare Workers環境を起動します。'
+            : '<http://127.0.0.1:3000> へアクセスするとJSONレスポンスを返します。',
+    ].join('\n');
+}
+function deploymentSection(options) {
+    if (options.target === 'cloudflare-workers') {
+        return [
+            '## Deploy',
+            '',
+            '```sh',
+            runScriptCommand(options.packageManager, 'deploy'),
+            '```',
+        ].join('\n');
+    }
+    if (options.target === 'aws-lambda') {
+        return [
+            '## Build',
+            '',
+            '```sh',
+            runScriptCommand(options.packageManager, 'build'),
+            '```',
+            '',
+            '`dist/index.mjs`の`handler`をAWS Lambdaのhandlerとしてdeployします。',
+        ].join('\n');
+    }
+    return [
+        '## Production',
+        '',
+        '```sh',
+        ...(options.target === 'deno'
+            ? []
+            : [runScriptCommand(options.packageManager, 'build')]),
+        runScriptCommand(options.packageManager, 'start'),
+        '```',
+    ].join('\n');
+}
+async function renderTextTemplate(path, values) {
+    let content = await readFile(path, 'utf8');
+    for (const [name, value] of Object.entries(values)) {
+        content = content.replaceAll(`{{${name}}}`, value);
+    }
+    await writeFile(path, content, 'utf8');
+}
+async function replaceText(path, search, replacement) {
+    const content = await readFile(path, 'utf8');
+    await writeFile(path, content.replaceAll(search, replacement), 'utf8');
+}
+function workerNameFor(packageName) {
+    return (packageName
+        .replace(/[^a-z0-9-]+/gu, '-')
+        .replace(/^-+|-+$/gu, '')
+        .slice(0, 63) || 'loutre-worker');
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "create-loutre",
+  "version": "0.1.0",
+  "description": "Loutre project initializer",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-loutre": "bin/create-loutre.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "templates"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@loutrejs/loutre": "^0.1.0",
+    "commander": "^15.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/come25136/loutrejs",
+    "directory": "packages/create-loutre"
+  }
+}

package/templates/base/README.md

@@ -0,0 +1,13 @@
+# Loutre Application
+
+Loutreで作成した{{targetLabel}}向けApplicationです。
+
+{{developmentSection}}
+
+## 検証
+
+```sh
+{{verifyCommand}}
+```
+
+{{deploymentSection}}

package/templates/base/_gitignore

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+coverage/
+.env

package/templates/base/_oxfmtrc.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "endOfLine": "lf",
+  "proseWrap": "preserve",
+  "sortPackageJson": false,
+  "ignorePatterns": ["dist/**", "coverage/**", "node_modules/**"]
+}

package/templates/base/_oxlintrc.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "categories": {
+    "correctness": "error",
+    "suspicious": "error"
+  },
+  "ignorePatterns": ["dist/**", "coverage/**", "node_modules/**"]
+}

package/templates/base/src/app.test.ts

@@ -0,0 +1,15 @@
+import { bootstrap } from '@loutrejs/loutre/host'
+import { expect, it } from 'vitest'
+import application from './app.js'
+
+it('GET / がLoutre Applicationのレスポンスを返す', async () => {
+  const app = bootstrap({ application })
+  try {
+    const response = await app.fetch(new Request('http://localhost/'))
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ message: 'Hello from Loutre!' })
+  } finally {
+    await app.close('test-complete')
+  }
+})

package/templates/base/src/app.ts

@@ -0,0 +1,55 @@
+import {
+  contract,
+  defineApplication,
+  defineModule,
+  implementation,
+  procedure,
+} from '@loutrejs/loutre'
+import { http } from '@loutrejs/loutre/http'
+import { z } from 'zod'
+
+const AppContract = contract(
+  {
+    hello: procedure({
+      protocols: {
+        http: http({
+          method: 'GET',
+          path: '/',
+          responses: {
+            ok: {
+              status: 200,
+              body: z.object({
+                message: z.string(),
+              }),
+            },
+          },
+          pipeline: [http.controller],
+        }),
+      },
+    }),
+  },
+  { name: 'AppContract' },
+)
+
+const AppController = implementation({
+  name: 'AppController',
+  contract: AppContract,
+  protocol: http,
+  factory: () => ({
+    async hello(ctx) {
+      return ctx.response.ok({
+        body: { message: 'Hello from Loutre!' },
+      })
+    },
+  }),
+})
+
+const AppModule = defineModule(() => ({
+  name: 'AppModule',
+  description: 'HTTP Applicationのentry module',
+  implementations: [AppController],
+}))
+
+export default defineApplication({
+  modules: [AppModule()],
+})

package/templates/base/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "useDefineForClassFields": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "skipLibCheck": true,
+    "types": "__LOUTRE_TYPES__"
+  },
+  "include": ["src/**/*.ts"]
+}

package/templates/base/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+})

package/templates/targets/aws-lambda/src/main.ts

@@ -0,0 +1,4 @@
+import { awsLambdaRuntime } from '@loutrejs/loutre/runtime/aws-lambda'
+import application from './app.js'
+
+export const handler = awsLambdaRuntime.bind({ application })

package/templates/targets/bun/src/main.ts

@@ -0,0 +1,10 @@
+import { bunRuntime } from '@loutrejs/loutre/runtime/bun'
+import application from './app.js'
+
+await bunRuntime.serve({
+  application,
+  hostname: '127.0.0.1',
+  port: 3000,
+})
+
+console.log('Loutre is swimming at http://127.0.0.1:3000')

package/templates/targets/cloudflare-workers/src/main.ts

@@ -0,0 +1,4 @@
+import { cloudflareWorkersRuntime } from '@loutrejs/loutre/runtime/cloudflare-workers'
+import application from './app.js'
+
+export default cloudflareWorkersRuntime.bind({ application })

package/templates/targets/cloudflare-workers/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+  "$schema": "./node_modules/wrangler/config-schema.json",
+  "name": "{{packageName}}",
+  "main": "src/main.ts",
+  "compatibility_date": "{{compatibilityDate}}",
+}

package/templates/targets/deno/src/main.ts

@@ -0,0 +1,10 @@
+import { denoRuntime } from '@loutrejs/loutre/runtime/deno'
+import application from './app.ts'
+
+await denoRuntime.serve({
+  application,
+  hostname: '127.0.0.1',
+  port: 3000,
+})
+
+console.log('Loutre is swimming at http://127.0.0.1:3000')

package/templates/targets/node/src/main.ts

@@ -0,0 +1,16 @@
+import { nodeRuntime } from '@loutrejs/node'
+import application from './app.js'
+
+const server = await nodeRuntime.serve({
+  application,
+  hostname: '127.0.0.1',
+  port: 3000,
+})
+
+console.log('Loutre is swimming at http://127.0.0.1:3000')
+
+for (const signal of ['SIGINT', 'SIGTERM'] as const) {
+  process.once(signal, () => {
+    void server.close(signal)
+  })
+}

package/templates/targets/node/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["src/**/*.test.ts"]
+}