create-loutre 0.4.1 → 0.6.0

package/dist/app.d.ts

@@ -12,9 +12,10 @@ export interface CreateProjectResult {
 export declare class ProjectScaffolder {
     create(input: CreateProjectInput): Promise<CreateProjectResult>;
 }
-export declare const createProject: import("@loutrejs/loutre").TaskDescriptor<CreateProjectInput, CreateProjectResult, string>;
+export declare const createProject: import("@loutrejs/loutre/tasks").TaskDefinition<CreateProjectInput, CreateProjectResult>;
 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 []>;
+    readonly executions: readonly [import("@loutrejs/loutre/tasks").TaskDefinition<CreateProjectInput, CreateProjectResult>];
+}>], undefined>;
 export default _default;

package/dist/app.js

@@ -1,6 +1,7 @@
 import { readdir } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
-import { defineApplication, defineModule, inject, task } from '@loutrejs/loutre';
+import { defineApplication, defineModule, inject } from '@loutrejs/loutre';
+import { task } from '@loutrejs/loutre/tasks';
 import { writeStarter } from './starter.js';
 export class ProjectScaffolder {
     async create(input) {
@@ -22,11 +23,9 @@ export const createProject = task({
 const CreateLoutreModule = defineModule(() => ({
     name: 'CreateLoutreModule',
     providers: [ProjectScaffolder],
+    executions: [createProject],
 }));
-export default defineApplication({
-    modules: [CreateLoutreModule()],
-    tasks: [createProject],
-});
+export default defineApplication({ modules: [CreateLoutreModule()] });
 async function assertTargetIsEmpty(targetDirectory) {
     try {
         const entries = await readdir(targetDirectory);

package/dist/cli.js

@@ -2,10 +2,10 @@ 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 { bootstrapApplication } from '@loutrejs/loutre';
 import { detectPresentationTerminal, renderLoutreBrand, } from '@loutrejs/loutre/presentation';
 import application, { createProject } from './app.js';
-import { installCommand, packageManagerLabels, packageManagers, projectTargets, runScriptCommand, targetLabels, } from './options.js';
+import { createIsTarget, installCommand, packageManagerLabels, packageManagers, projectTargets, runScriptCommand, targetLabels, } from './options.js';
 export async function runCreateLoutre(args, io = createProcessIO()) {
     const parsed = parseArgs(args);
     if ('error' in parsed) {
@@ -27,9 +27,9 @@ export async function runCreateLoutre(args, io = createProcessIO()) {
     const packageManager = await resolvePackageManager(parsed.packageManager, parsed.yes, io);
     if (!packageManager)
         return 2;
-    const app = bootstrap({ application });
+    const app = await bootstrapApplication({ application });
     try {
-        const result = await app.run(createProject, {
+        const result = await app.tasks.run(createProject, {
             cwd: io.cwd,
             directory,
             packageManager,
@@ -190,7 +190,8 @@ function detectPackageManager(userAgent, runtime) {
     return (packageManagers.find((packageManager) => packageManager === name) ?? 'npm');
 }
 function nextCommand(packageManager, target) {
-    return runScriptCommand(packageManager, target === 'aws-lambda' ? 'build' : 'dev');
+    const isTarget = createIsTarget(target);
+    return runScriptCommand(packageManager, isTarget('aws-lambda') ? 'build' : 'dev');
 }
 function quoteShellArgument(value) {
     return /^[A-Za-z0-9_./-]+$/u.test(value)

package/dist/options.d.ts

@@ -1,5 +1,7 @@
-export declare const projectTargets: readonly ['node', 'bun', 'deno', 'cloudflare-workers', 'aws-lambda'];
-export type ProjectTarget = (typeof projectTargets)[number];
+import type { RuntimeEngine } from '@loutrejs/loutre/runtime';
+export declare const projectTargets: readonly ["node", "bun", "deno", "cloudflare-workers", "aws-lambda"];
+export type ProjectTarget = Exclude<RuntimeEngine, 'electron' | 'unknown'>;
+export declare function createIsTarget(target: ProjectTarget): (candidate: ProjectTarget) => boolean;
 export declare const packageManagers: readonly ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
 export type PackageManager = (typeof packageManagers)[number];
 export declare const targetLabels: Readonly<Record<ProjectTarget, string>>;

package/dist/options.js

@@ -5,6 +5,9 @@ export const projectTargets = [
     'cloudflare-workers',
     'aws-lambda',
 ];
+export function createIsTarget(target) {
+    return (candidate) => target === candidate;
+}
 export const packageManagers = ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
 export const targetLabels = {
     node: 'Node.js',

package/dist/starter.js

@@ -1,8 +1,8 @@
 import { readFileSync } from 'node:fs';
-import { cp, readFile, rename, writeFile } from 'node:fs/promises';
+import { cp, readFile, readdir, rename, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { runScriptCommand, targetLabels, } from './options.js';
+import { createIsTarget, 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) {
@@ -19,6 +19,7 @@ const renamedTemplateFiles = new Map([
     ['_oxfmtrc.json', '.oxfmtrc.json'],
 ]);
 export async function writeStarter(targetDirectory, options) {
+    const isTarget = createIsTarget(options.target);
     await cp(baseTemplateDirectory, targetDirectory, { recursive: true });
     await cp(join(targetsTemplateDirectory, options.target), targetDirectory, {
         recursive: true,
@@ -34,7 +35,10 @@ export async function writeStarter(targetDirectory, options) {
         verifyCommand: runScriptCommand(options.packageManager, 'verify'),
         deploymentSection: deploymentSection(options),
     });
-    if (options.target === 'cloudflare-workers') {
+    if (isTarget('deno')) {
+        await rewriteLocalImportExtensionsForDeno(join(targetDirectory, 'src'));
+    }
+    if (isTarget('cloudflare-workers')) {
         await renderTextTemplate(join(targetDirectory, 'wrangler.jsonc'), {
             packageName: workerNameFor(options.packageName),
             compatibilityDate: new Date().toISOString().slice(0, 10),
@@ -134,7 +138,8 @@ function renderPackageJson(options) {
     }, null, 2)}\n`;
 }
 function developmentSection(options) {
-    if (options.target === 'aws-lambda') {
+    const isTarget = createIsTarget(options.target);
+    if (isTarget('aws-lambda')) {
         return [
             '## Development',
             '',
@@ -152,13 +157,14 @@ function developmentSection(options) {
         runScriptCommand(options.packageManager, 'dev'),
         '```',
         '',
-        options.target === 'cloudflare-workers'
+        isTarget('cloudflare-workers')
             ? 'Wrangler starts a local Cloudflare Workers environment.'
             : 'Open <http://127.0.0.1:3000> to receive a JSON response.',
     ].join('\n');
 }
 function deploymentSection(options) {
-    if (options.target === 'cloudflare-workers') {
+    const isTarget = createIsTarget(options.target);
+    if (isTarget('cloudflare-workers')) {
         return [
             '## Deploy',
             '',
@@ -167,7 +173,7 @@ function deploymentSection(options) {
             '```',
         ].join('\n');
     }
-    if (options.target === 'aws-lambda') {
+    if (isTarget('aws-lambda')) {
         return [
             '## Build',
             '',
@@ -182,7 +188,7 @@ function deploymentSection(options) {
         '## Production',
         '',
         '```sh',
-        ...(options.target === 'deno'
+        ...(isTarget('deno')
             ? []
             : [runScriptCommand(options.packageManager, 'build')]),
         runScriptCommand(options.packageManager, 'start'),
@@ -200,6 +206,20 @@ async function replaceText(path, search, replacement) {
     const content = await readFile(path, 'utf8');
     await writeFile(path, content.replaceAll(search, replacement), 'utf8');
 }
+async function rewriteLocalImportExtensionsForDeno(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            await rewriteLocalImportExtensionsForDeno(path);
+            return;
+        }
+        if (!entry.isFile() || !entry.name.endsWith('.ts'))
+            return;
+        const content = await readFile(path, 'utf8');
+        await writeFile(path, content.replaceAll(/(from\s+['"]\.{1,2}\/[^'"]+)\.js(['"])/gu, '$1.ts$2'), 'utf8');
+    }));
+}
 function workerNameFor(packageName) {
     return (packageName
         .replace(/[^a-z0-9-]+/gu, '-')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loutre",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Loutre project initializer",
   "license": "MIT",
   "type": "module",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@loutrejs/loutre": "^0.4.1",
+    "@loutrejs/loutre": "^0.6.0",
     "commander": "^15.0.0"
   },
   "repository": {

package/templates/base/README.md

@@ -4,6 +4,20 @@ A Loutre Application for {{targetLabel}}.
 
 {{developmentSection}}
 
+## Structure
+
+```text
+src/
+├ app.ts
+├ app.test.ts
+├ hello/
+│  ├ contract.ts
+│  └ controller.ts
+└ main.ts
+```
+
+Keep `app.ts` focused on root Application wiring. Group application code by feature or integration as the project grows.
+
 ## Verify
 
 ```sh

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

@@ -1,11 +1,15 @@
-import { bootstrap } from '@loutrejs/loutre/host'
+import { bootstrapApplication } from '@loutrejs/loutre'
+import { bindHttpServer } from '@loutrejs/loutre/http'
 import { expect, it } from 'vitest'
 import application from './app.js'
 
 it('GET / returns a response from the Loutre Application', async () => {
-  const app = bootstrap({ application })
+  const app = await bootstrapApplication({
+    application,
+    capabilities: [bindHttpServer({ runtime: 'test' })],
+  })
   try {
-    const response = await app.fetch(new Request('http://localhost/'))
+    const response = await app.http.fetch(new Request('http://localhost/'))
 
     expect(response.status).toBe(200)
     expect(await response.json()).toEqual({ message: 'Hello from Loutre!' })

package/templates/base/src/app.ts

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

package/templates/base/src/hello/contract.ts

@@ -0,0 +1,17 @@
+import { http } from '@loutrejs/loutre/http'
+import { z } from 'zod'
+
+export const AppContract = http.contract({
+  hello: {
+    method: 'GET',
+    path: '/',
+    responses: {
+      ok: {
+        status: 200,
+        body: z.object({
+          message: z.string(),
+        }),
+      },
+    },
+  },
+})

package/templates/base/src/hello/controller.ts

@@ -0,0 +1,14 @@
+import { http } from '@loutrejs/loutre/http'
+import { AppContract } from './contract.js'
+
+export const AppController = http.implementation({
+  name: 'AppController',
+  contract: AppContract,
+  factory: () => ({
+    async hello(ctx) {
+      return ctx.response.ok({
+        body: { message: 'Hello from Loutre!' },
+      })
+    },
+  }),
+})

package/templates/base/tsconfig.json

@@ -1,6 +1,15 @@
 {
   "compilerOptions": {
     "target": "ES2024",
+    "lib": [
+      "ES2024",
+      "DOM",
+      "WebWorker.ImportScripts",
+      "ScriptHost",
+      "DOM.Iterable",
+      "DOM.AsyncIterable",
+      "ESNext.Disposable"
+    ],
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "strict": true,