@oyolincc/create 0.0.0-dev-20260918103756 → 0.0.0-dev-20261006065712

package/templates/monorepo/turbo.json

@@ -1,13 +1,36 @@
 {
   "$schema": "https://turbo.build/schema.json",
   "tasks": {
-    "build": {
+    "dev": {
       "dependsOn": ["^build"],
-      "outputs": ["dist/**", ".output/**"]
+      "cache": false,
+      "persistent": true
     },
-    "dev": {
+    "dev:node": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "cache": false,
+      "persistent": true
+    },
+    "dev:cloudflare": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
       "cache": false,
       "persistent": true
+    },
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**", ".output/**"]
+    },
+    "build:node": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "outputs": ["dist/**", ".output/**"]
+    },
+    "build:cloudflare": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "outputs": ["dist/**", ".output/**"]
     }
   }
 }

package/templates/monorepo/vite.config.ts

@@ -2,6 +2,7 @@ import { defineConfig } from 'vite-plus'
 import { lintConfig, fmtConfig } from '@oyolincc/dev-config'
 
 export default defineConfig({
+  create: { defaultTemplate: '@oyolincc' },
   staged: {
     '*': 'vp check --fix',
   },

package/templates/hono-fullstack/apps/server/src/adapters/nodejs/config.ts

@@ -1,53 +0,0 @@
-import type { AppConfig } from '@/shared/app/types'
-import {
-  corsConfig,
-  logBaseConfig,
-  logPrettyRawConfig,
-  logRollRawConfig,
-  logRollSchemaConfig,
-  runtimeConfig,
-  workerConfig,
-  type WorkerConfig,
-} from '@repo/definition/backend'
-import { flatten as flattenValiIssues, isValiError } from 'valibot'
-
-export function resolveConfig(context: Record<string, unknown>): AppConfig {
-  try {
-    const fromEnv = { context, matchContextKey: 'constantCase' as const }
-    const runtime = runtimeConfig.resolve(fromEnv)
-    const logBaseParsed = logBaseConfig.resolve(fromEnv)
-    const logRollSchemaParsed = logRollSchemaConfig.resolve(fromEnv)
-    const worker = workerConfig.resolve(fromEnv)
-    const cors = corsConfig.resolve({
-      context: { domains: context.CORS_DOMAINS },
-      matchContextKey: 'camel',
-    })
-
-    return {
-      runtime: { ...runtime, isLocal: runtime.serverEnv === 'local' },
-      log: {
-        base: logBaseParsed,
-        roll: { ...logRollSchemaParsed, ...logRollRawConfig.resolve() },
-        pretty: logPrettyRawConfig.resolve(),
-      },
-      middleware: { cors },
-      worker,
-    }
-  } catch (error) {
-    if (isValiError(error)) {
-      throw new Error(`[resolveAppConfig] ${JSON.stringify(flattenValiIssues(error.issues))}`)
-    }
-    throw error
-  }
-}
-
-export function resolveWorkerConfig(context: Record<string, unknown>): WorkerConfig {
-  try {
-    return workerConfig.resolve({ context, matchContextKey: 'constantCase' })
-  } catch (error) {
-    if (isValiError(error)) {
-      throw new Error(`[resolveWorkerConfig] ${JSON.stringify(flattenValiIssues(error.issues))}`)
-    }
-    throw error
-  }
-}

package/templates/hono-fullstack/apps/server/src/app.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-import { createApp } from './app'
-import type { AppDependencies, AppLogger } from './shared/app/types'
-
-const logger = new Proxy(
-  { assign() {} },
-  { get: (target, key) => Reflect.get(target, key) || (() => {}) },
-) as AppLogger
-const dependencies = {
-  appConfig: { middleware: { cors: { domains: ['*'] } } },
-  loggerHandler: async (c: any, next: () => Promise<void>) => {
-    c.set('logger', logger)
-    await next()
-  },
-  exampleWorkRunner: {
-    async run(task: any) {
-      const original = task.input.message
-      const normalized = original.trim().replace(/\s+/g, ' ')
-      return { ok: true as const, data: { original, normalized, length: normalized.length } }
-    },
-    async shutdown() {},
-  },
-} as unknown as AppDependencies
-
-describe('HTTP contracts', () => {
-  const app = createApp(() => dependencies)
-
-  it('wraps successful responses in data', async () => {
-    const response = await app.request('/health')
-    expect(response.status).toBe(200)
-    await expect(response.json()).resolves.toEqual({ data: { status: 'ok' } })
-  })
-
-  it('returns Problem Details for missing routes', async () => {
-    const response = await app.request('/missing')
-    expect(response.status).toBe(404)
-    await expect(response.json()).resolves.toMatchObject({ status: 404, type: 'NORMAL.NOT_FOUND' })
-  })
-
-  it('returns validation Problem Details with status 422', async () => {
-    const response = await app.request('/examples/process', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ message: '' }),
-    })
-    expect(response.status).toBe(422)
-    await expect(response.json()).resolves.toMatchObject({
-      status: 422,
-      type: 'NORMAL.VALIDATION',
-    })
-  })
-})

package/templates/hono-fullstack/apps/server/src/infra/work-runner/example/runner.test.ts

@@ -1,56 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
-import { WorkerErrorCode, WorkSubject } from '../constants'
-import { ExampleWorkRunner } from './runner'
-
-vi.mock('@/infra/logger/getter', () => ({
-  getLogger: () =>
-    new Proxy({ assign() {} }, { get: (target, key) => Reflect.get(target, key) || (() => {}) }),
-}))
-vi.mock('virtual:workers', () => ({ default: '/tmp' }))
-vi.mock('piscina', () => ({
-  default: class PiscinaMock {
-    idleThreads = 1
-    threads: unknown[] = []
-    queueSize = 0
-    options = { maxQueue: 1 }
-
-    run() {
-      throw new Error('An aborted task must not reach the worker pool')
-    }
-
-    async close() {}
-  },
-}))
-
-const config = {
-  minThreads: 1,
-  maxThreads: 1,
-  concurrentTasksPerWorker: 1,
-  maxQueue: 1,
-  workerTaskTimeoutMs: 1_000,
-}
-
-describe('ExampleWorkRunner cancellation', () => {
-  let runner: ExampleWorkRunner | undefined
-
-  afterEach(async () => {
-    await runner?.shutdown()
-    runner = undefined
-  })
-
-  it('returns the task-aborted error model for an aborted signal', async () => {
-    runner = ExampleWorkRunner.getInstance(config)
-    const controller = new AbortController()
-    controller.abort()
-
-    await expect(
-      runner.run(
-        { subject: WorkSubject.PROCESS_EXAMPLE, input: { message: 'hello' } },
-        { signal: controller.signal },
-      ),
-    ).resolves.toMatchObject({
-      ok: false,
-      error: { code: WorkerErrorCode.TASK_ABORTED },
-    })
-  })
-})

package/templates/hono-fullstack/apps/stack/frontend/modules/example/ExamplePage.tsx

@@ -1,57 +0,0 @@
-import { useState, type FormEvent } from 'react'
-import { useCreateExample, useExamples, useProcessExample } from './hooks'
-
-export function ExamplePage() {
-  const [message, setMessage] = useState('')
-  const examples = useExamples()
-  const create = useCreateExample()
-  const process = useProcessExample()
-
-  const submit = async (event: FormEvent) => {
-    event.preventDefault()
-    await create.mutateAsync({ message })
-    setMessage('')
-  }
-
-  return (
-    <main className="mx-auto flex min-h-screen max-w-2xl flex-col gap-6 p-8">
-      <header>
-        <h1 className="text-3xl font-bold">Example workspace</h1>
-        <p className="text-zinc-400">Nitro mounts the independent Hono server under /api.</p>
-      </header>
-      <form className="flex gap-2" onSubmit={submit}>
-        <input
-          className="min-w-0 flex-1 rounded border border-zinc-700 bg-zinc-900 px-3 py-2"
-          value={message}
-          onChange={(event) => setMessage(event.target.value)}
-          placeholder="Message"
-        />
-        <button
-          className="rounded bg-blue-600 px-4 py-2"
-          disabled={!message.trim() || create.isPending}>
-          Save
-        </button>
-        <button
-          className="rounded bg-emerald-600 px-4 py-2"
-          type="button"
-          disabled={!message.trim() || process.isPending}
-          onClick={() => process.mutate({ message })}>
-          Process
-        </button>
-      </form>
-      {process.data && (
-        <pre className="rounded bg-zinc-900 p-4">{JSON.stringify(process.data, null, 2)}</pre>
-      )}
-      {(create.error || process.error || examples.error) && (
-        <p className="text-red-400">{String(create.error || process.error || examples.error)}</p>
-      )}
-      <ul className="grid gap-2">
-        {examples.data?.map((example) => (
-          <li className="rounded border border-zinc-800 p-3" key={example.id}>
-            {example.message}
-          </li>
-        ))}
-      </ul>
-    </main>
-  )
-}

package/templates/hono-fullstack/apps/stack/nitro/handlers/hono.ts

@@ -1 +0,0 @@
-export { default } from '@repo/server/node'

package/templates/hono-fullstack/apps/stack/nitro/plugins/hono.ts

@@ -1,9 +0,0 @@
-import { definePlugin } from 'nitro'
-import { exampleWorkRunner, sqliteClient } from '@repo/server/node'
-
-export default definePlugin((nitro) => {
-  nitro.hooks.hook('close', async () => {
-    await exampleWorkRunner.shutdown()
-    sqliteClient.close()
-  })
-})

package/templates/hono-server/apps/server/src/adapters/nodejs/config.ts

@@ -1,53 +0,0 @@
-import type { AppConfig } from '@/shared/app/types'
-import {
-  corsConfig,
-  logBaseConfig,
-  logPrettyRawConfig,
-  logRollRawConfig,
-  logRollSchemaConfig,
-  runtimeConfig,
-  workerConfig,
-  type WorkerConfig,
-} from '@repo/definition/backend'
-import { flatten as flattenValiIssues, isValiError } from 'valibot'
-
-export function resolveConfig(context: Record<string, unknown>): AppConfig {
-  try {
-    const fromEnv = { context, matchContextKey: 'constantCase' as const }
-    const runtime = runtimeConfig.resolve(fromEnv)
-    const logBaseParsed = logBaseConfig.resolve(fromEnv)
-    const logRollSchemaParsed = logRollSchemaConfig.resolve(fromEnv)
-    const worker = workerConfig.resolve(fromEnv)
-    const cors = corsConfig.resolve({
-      context: { domains: context.CORS_DOMAINS },
-      matchContextKey: 'camel',
-    })
-
-    return {
-      runtime: { ...runtime, isLocal: runtime.serverEnv === 'local' },
-      log: {
-        base: logBaseParsed,
-        roll: { ...logRollSchemaParsed, ...logRollRawConfig.resolve() },
-        pretty: logPrettyRawConfig.resolve(),
-      },
-      middleware: { cors },
-      worker,
-    }
-  } catch (error) {
-    if (isValiError(error)) {
-      throw new Error(`[resolveAppConfig] ${JSON.stringify(flattenValiIssues(error.issues))}`)
-    }
-    throw error
-  }
-}
-
-export function resolveWorkerConfig(context: Record<string, unknown>): WorkerConfig {
-  try {
-    return workerConfig.resolve({ context, matchContextKey: 'constantCase' })
-  } catch (error) {
-    if (isValiError(error)) {
-      throw new Error(`[resolveWorkerConfig] ${JSON.stringify(flattenValiIssues(error.issues))}`)
-    }
-    throw error
-  }
-}

package/templates/hono-server/apps/server/src/app.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-import { createApp } from './app'
-import type { AppDependencies, AppLogger } from './shared/app/types'
-
-const logger = new Proxy(
-  { assign() {} },
-  { get: (target, key) => Reflect.get(target, key) || (() => {}) },
-) as AppLogger
-const dependencies = {
-  appConfig: { middleware: { cors: { domains: ['*'] } } },
-  loggerHandler: async (c: any, next: () => Promise<void>) => {
-    c.set('logger', logger)
-    await next()
-  },
-  exampleWorkRunner: {
-    async run(task: any) {
-      const original = task.input.message
-      const normalized = original.trim().replace(/\s+/g, ' ')
-      return { ok: true as const, data: { original, normalized, length: normalized.length } }
-    },
-    async shutdown() {},
-  },
-} as unknown as AppDependencies
-
-describe('HTTP contracts', () => {
-  const app = createApp(() => dependencies)
-
-  it('wraps successful responses in data', async () => {
-    const response = await app.request('/health')
-    expect(response.status).toBe(200)
-    await expect(response.json()).resolves.toEqual({ data: { status: 'ok' } })
-  })
-
-  it('returns Problem Details for missing routes', async () => {
-    const response = await app.request('/missing')
-    expect(response.status).toBe(404)
-    await expect(response.json()).resolves.toMatchObject({ status: 404, type: 'NORMAL.NOT_FOUND' })
-  })
-
-  it('returns validation Problem Details with status 422', async () => {
-    const response = await app.request('/examples/process', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ message: '' }),
-    })
-    expect(response.status).toBe(422)
-    await expect(response.json()).resolves.toMatchObject({
-      status: 422,
-      type: 'NORMAL.VALIDATION',
-    })
-  })
-})

package/templates/hono-server/apps/server/src/infra/work-runner/example/runner.test.ts

@@ -1,56 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
-import { WorkerErrorCode, WorkSubject } from '../constants'
-import { ExampleWorkRunner } from './runner'
-
-vi.mock('@/infra/logger/getter', () => ({
-  getLogger: () =>
-    new Proxy({ assign() {} }, { get: (target, key) => Reflect.get(target, key) || (() => {}) }),
-}))
-vi.mock('virtual:workers', () => ({ default: '/tmp' }))
-vi.mock('piscina', () => ({
-  default: class PiscinaMock {
-    idleThreads = 1
-    threads: unknown[] = []
-    queueSize = 0
-    options = { maxQueue: 1 }
-
-    run() {
-      throw new Error('An aborted task must not reach the worker pool')
-    }
-
-    async close() {}
-  },
-}))
-
-const config = {
-  minThreads: 1,
-  maxThreads: 1,
-  concurrentTasksPerWorker: 1,
-  maxQueue: 1,
-  workerTaskTimeoutMs: 1_000,
-}
-
-describe('ExampleWorkRunner cancellation', () => {
-  let runner: ExampleWorkRunner | undefined
-
-  afterEach(async () => {
-    await runner?.shutdown()
-    runner = undefined
-  })
-
-  it('returns the task-aborted error model for an aborted signal', async () => {
-    runner = ExampleWorkRunner.getInstance(config)
-    const controller = new AbortController()
-    controller.abort()
-
-    await expect(
-      runner.run(
-        { subject: WorkSubject.PROCESS_EXAMPLE, input: { message: 'hello' } },
-        { signal: controller.signal },
-      ),
-    ).resolves.toMatchObject({
-      ok: false,
-      error: { code: WorkerErrorCode.TASK_ABORTED },
-    })
-  })
-})