rajt 0.0.82 → 0.0.84

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "type": "module",
   "main": "./src/index.ts",
   "bin": {
@@ -39,11 +39,10 @@
   },
   "dependencies": {
     "cripta": "^0.1",
-    "forj": "^0.0.6",
+    "forj": "^0.0.8",
     "t0n": "^0.1",
     "@hono/node-server": "^1.19.9",
     "@hono/standard-validator": "^0.2.2",
-    "@iarna/toml": "^2.2.5",
     "@scalar/hono-api-reference": "^0.9.40",
     "chokidar-cli": "^3.0.0",
     "citty": "^0.1.6",
@@ -51,6 +50,8 @@
     "esbuild": "^0.25.2",
     "hono": "^4.11.7",
     "hono-openapi": "^1.2.0",
+    "localflare-api": "^0.4.2",
+    "localflare-core": "^0.4.2",
     "miniflare": "^4.20251217.0",
     "quansync": "^0.2.11",
     "tiny-glob": "^0.2",

package/src/cli/commands/build.ts

@@ -1,9 +1,9 @@
 import { defineCommand } from 'citty'
 import { gray } from '../../utils/colors'
-import { build, normalizePlatform, platformError } from './utils'
+import { build, normalizePlatform, platformError } from '../utils'
 import { wait, error, rn } from '../../utils/log'
 
-import { platforms } from './constants'
+import { platforms } from '../constants'
 
 export default defineCommand({
 	meta: {

package/src/cli/commands/deploy.ts

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process'
 import { defineCommand } from 'citty'
 
-import { _root, normalizePlatform, platformError, getRuntime } from './utils'
+import { _root, normalizePlatform, platformError, getRuntime } from '../utils'
 import { error } from '../../utils/log'
-import { platforms } from './constants'
+import { platforms } from '../constants'
 
 import build from './build'
 

package/src/cli/commands/dev.ts

@@ -3,7 +3,11 @@ import { spawn, type ChildProcess } from 'node:child_process'
 
 import { defineCommand } from 'citty'
 import type { Miniflare } from 'miniflare'
-import { _root, build, wait, watch, normalizePlatform, platformError, getRuntime, createMiniflare, getDockerHost } from './utils'
+import {
+	_root, build, wait, watch, normalizePlatform, platformError, getRuntime,
+	wranglerConfig, createMiniflare, localflareManifest,
+	getDockerHost
+} from '../utils'
 import { error, event, log, rn, warn } from '../../utils/log'
 import { withPort } from '../../utils/port'
 import shutdown from '../../utils/shutdown'
@@ -103,6 +107,8 @@ export default defineCommand({
 
 		const started = (port: number) => {
 			log(`Starting API on http://${host}:${port}`)
+			if (platform == 'cf')
+				log(`Localflare on https://studio.localflare.dev`)
 			rn()
 		}
 
@@ -156,9 +162,28 @@ export default defineCommand({
 				return withPort(desiredPort, async (port) => {
 					started(port)
 					let worker: Miniflare | null = null
+					let localflare: Miniflare | null = null
 					const startWorker = async () => {
 						if (worker) await worker.dispose()
-						worker = await createMiniflare({ port, host, liveReload: false })
+						if (localflare) await localflare.dispose()
+
+						const workerConfig = await wranglerConfig()
+						workerConfig.host = host
+						workerConfig.liveReload = false
+
+						worker = createMiniflare({ ...workerConfig, port })
+						await worker.ready
+						localflare = createMiniflare({
+							...workerConfig,
+							vars: {
+								...workerConfig.vars,
+								LOCALFLARE_MANIFEST: JSON.stringify(localflareManifest(workerConfig)),
+							},
+							main: 'node_modules/localflare-api/dist/worker/index.js',
+							port: 8788,
+							inspectorPort: 9230,
+						})
+						await localflare.ready
 					}
 
 					await startApp(startWorker)

package/src/cli/commands/make.ts

@@ -1,8 +1,9 @@
 import { defineCommand } from 'citty'
 import { join, relative } from 'node:path'
 import { Migrator } from 'forj'
-import { _root, makeFile, hasExt, camelCase, kebabCase } from './utils'
+import { _root, makeFile, hasExt, camelCase, kebabCase } from '../utils'
 import { event, error } from '../../utils/log'
+import * as stub from '../stubs'
 
 export default defineCommand({
 	meta: {
@@ -31,32 +32,20 @@ export default defineCommand({
 			case 'endpoint':
 				fileName = path(kebabCase(name))
 				if (!fileName.endsWith('.ts')) fileName += '.ts'
-				const className = camelCase(name)
-				makeFile(fileName, `import { Action } from 'rajt'
-import { IRequest, IResponse } from 'rajt/types'
-
-export default class ${className} extends Action {
-	static async handle(req: IRequest, res: IResponse) {
-		return res.ok('${className}')
-	}
-}
-`)
+				makeFile(fileName, stub.replace(stub.route, { R_NAME: camelCase(name) }))
 				break
 			case 'migrate':
 			case 'migration':
-				fileName = path(Migrator.fileName(name), 'migration')
+				fileName = Migrator.fileName(name)
+				const [table, create] = Migrator.guess(fileName)
+				fileName = path(fileName, 'migration')
 				if (!fileName.endsWith('.ts')) fileName += '.ts'
-				makeFile(fileName, `import { Migration, Schema, Blueprint } from 'rajt/db'
-
-export default class ${Migrator.className(name)} extends Migration {
-	static async run() {
-		Schema.${name.includes('create') ? 'create' : 'table'}('users', (table: Blueprint) => {
-			table.id()
-			table.timestamps()
-		})
-	}
-}
-`)
+				makeFile(fileName, stub.replace(stub.migration, {
+					M_NAME: Migrator.className(name),
+					S_NAME: create ? 'create' : 'table',
+					T_NAME: table || 'TABLE_NAME',
+					M_CONTENT: create ? stub.migrationCreate : '//',
+				}))
 				break
 			case 'model':
 				error('Action not yet implemented, contact the webmaster')

package/src/cli/commands/migrate.ts

@@ -2,8 +2,8 @@ import { defineCommand } from 'citty'
 import { spawn } from 'node:child_process'
 import { Migrator } from 'forj'
 import { gray } from '../../utils/colors'
-import { _root, getRuntime } from './utils'
-import { wait, info, event, rn, error } from '../../utils/log'
+import { _root, getRuntime, cleanDir, d1Path, wait as WAIT } from '../utils'
+import { wait, info, event, rn, error, log } from '../../utils/log'
 
 export default defineCommand({
 	meta: {
@@ -34,11 +34,18 @@ export default defineCommand({
 			switch (action) {
 				case 'migrate':
 				case 'apply':
-					wait('Running migrations')
+				case 'fresh':
+				case 'refresh':
 					if (!pending?.length)
-						return info(' Nothing to migrate')
+						log('Nothing to compile')
+					wait('Running migrations')
+
+					if (action.includes('fresh')) {
+						cleanDir(d1Path)
+						await WAIT(2000)
+					}
 
-					await Migrator.compile(pending)
+					await Migrator.compile([...migrated, ...pending])
 
 					const child = spawn(
 						isBun ? 'bunx' : 'npx',
@@ -50,11 +57,8 @@ export default defineCommand({
 					)
 
 					child.on('exit', code => process.exit(code ?? 0))
-						.on('message', msg => {
-							process.send && process.send(msg)
-						}).on('disconnect', () => {
-							process.disconnect && process.disconnect()
-						})
+						.on('message', msg => process.send && process.send(msg))
+						.on('disconnect', () => process.disconnect && process.disconnect())
 
 					pending.forEach(item => event(item.name))
 					break

package/src/cli/commands/routes.ts

@@ -3,7 +3,7 @@ import { defineCommand } from 'citty'
 import { inspectRoutes } from 'hono/dev'
 import { IMPORT } from 't0n'
 import { gray, purple, red, yellow } from '../../utils/colors'
-import { __rajt } from './utils'
+import { __rajt } from '../utils'
 import { rn } from '../../utils/log'
 
 export default defineCommand({

package/src/cli/stubs.ts

@@ -0,0 +1,42 @@
+export const replace = (str: string, map: Record<string, string>) => {
+  if (!str || typeof str != 'string' || !map || typeof map != 'object') return str
+  const entries = Object.entries(map)
+  const length = entries?.length || 0
+  if (!length) return str
+
+  str = str.trimStart()
+  if (length == 1)
+    return str.replaceAll(entries[0][0], entries[0][1])
+
+  return entries.reduce(
+    (acc, entry) => acc.replace(new RegExp(entry[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), entry[1]),
+    str
+  )
+}
+
+export const route = `
+import { Action } from 'rajt'
+import { IRequest, IResponse } from 'rajt/types'
+
+export default class R_NAME extends Action {
+	static async handle(req: IRequest, res: IResponse) {
+		return res.ok('R_NAME')
+	}
+}
+`
+
+export const migration = `
+import { Migration, Schema, Blueprint } from 'rajt/db'
+
+export default class M_NAME extends Migration {
+  static async run() {
+    Schema.S_NAME('T_NAME', (table: Blueprint) => {
+      M_CONTENT
+    })
+  }
+}
+`
+export const migrationCreate = `
+      table.id()
+      table.timestamps()
+`.trim()

package/src/cli/{commands/utils.ts → utils.ts}

@@ -1,19 +1,21 @@
 import esbuild from 'esbuild'
-import TOML from '@iarna/toml'
 import { Miniflare } from 'miniflare'
-import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync, writeFileSync } from 'node:fs'
+import { mkdirSync, existsSync, statSync, readdirSync, rmSync, unlinkSync, copyFileSync, writeFileSync } from 'node:fs'
 import { readFile, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative } from 'node:path'
 
+import { findWranglerConfig, parseWranglerConfig, WRANGLER_CONFIG_FILES } from 'localflare-core'
+import type { WranglerConfig, LocalflareManifest } from 'localflare-core'
+
 import chokidar from 'chokidar'
-import { gray } from '../../utils/colors'
+import { gray, red } from '../utils/colors'
 import type { ChokidarEventName, Platform } from './types'
 
-import { cacheRoutes } from '../../routes'
-import { step, substep, event, error, wait as wwait, warn, log } from '../../utils/log'
+import { cacheRoutes } from '../routes'
+import { substep, event, error, wait as wwait, warn, log } from '../utils/log'
 import { platforms } from './constants'
 
-export const _root = join(dirname(new URL(import.meta.url).pathname), '../../../../../')
+export const _root = join(dirname(new URL(import.meta.url).pathname), '../../../../')
 export const __rajt = join(_root, 'node_modules/rajt/src')
 
 export function normalizePlatform(platform: Platform) {
@@ -71,16 +73,10 @@ export const build = async (platform: Platform) => {
   const startTime = Date.now()
 
   const isCF = platform == 'cf'
-  const distDir = join(_root, dist)
-
-  existsSync(distDir)
-    ? readdirSync(distDir).forEach(file => rmSync(join(distDir, file), { recursive: true, force: true }))
-    : mkdirSync(distDir, { recursive: true })
+  cleanDir(join(_root, dist))
 
   if (isCF) {
-    for (let file of [
-      'wrangler.toml',
-    ]) {
+    for (let file of WRANGLER_CONFIG_FILES) {
       file = join(_root, file)
       if (existsSync(file))
         copyFileSync(file, join(_root, dist, basename(file)))
@@ -181,54 +177,118 @@ export const build = async (platform: Platform) => {
   )
 }
 
-async function parseWranglerConfig(file: string) {
+export function cleanDir(path: string) {
+  try {
+    if (!existsSync(path))
+      return mkdirSync(path, {recursive: true})
+
+    const files = readdirSync(path)
+
+    for (const file of files) {
+      const filePath = join(path, file)
+      const stat = statSync(filePath)
+
+      stat.isDirectory()
+        ? rmSync(filePath, {recursive: true, force: true})
+        : unlinkSync(filePath)
+    }
+  } catch {}
+}
+
+export function wranglerConfig(file?: string) {
+  file ??= findWranglerConfig(_root)
+  if (!file) {
+    console.log(red(`  ✗ Could not find wrangler config file`))
+    console.log(red(`    Looking for: ${WRANGLER_CONFIG_FILES.join(', ')}`))
+    process.exit(1)
+  }
+
   try {
-    return TOML.parse(await readFile(join(_root, file), 'utf-8'))
+    return parseWranglerConfig(file)
   } catch (e) {
     warn(`Could not parse ${file}, using defaults`)
     return {}
   }
 }
 
-export async function createMiniflare(options = {}, configPath = 'wrangler.toml') {
-  const config = await parseWranglerConfig(configPath)
+export function localflareManifest(opts: WranglerConfig): LocalflareManifest {
+  return {
+    name: opts.name || 'worker',
+    d1: (opts.d1_databases || []).map((db) => ({
+      binding: db.binding,
+      database_name: db.database_name,
+    })),
+    kv: (opts.kv_namespaces || []).map((kv) => ({
+      binding: kv.binding,
+    })),
+    r2: (opts.r2_buckets || []).map((r2) => ({
+      binding: r2.binding,
+      bucket_name: r2.bucket_name,
+    })),
+    queues: {
+      producers: (opts.queues?.producers || []).map((p) => ({
+        binding: p.binding,
+        queue: p.queue,
+      })),
+      consumers: (opts.queues?.consumers || []).map((c) => ({
+        queue: c.queue,
+        max_batch_size: c.max_batch_size,
+        max_batch_timeout: c.max_batch_timeout,
+        max_retries: c.max_retries,
+        dead_letter_queue: c.dead_letter_queue,
+      })),
+    },
+    do: (opts.durable_objects?.bindings || []).map((d) => ({
+      binding: d.name,
+      className: d.class_name,
+    })),
+    vars: Object.entries(opts.vars || {}).map(([key, value]) => ({
+      key,
+      value,
+      isSecret: false,
+      // isSecret: looksLikeSecret(key, value),
+    })),
+  }
+}
+
+const wranglerPath = '.wrangler/state/v3'
+export const kvPath = join(_root, wranglerPath, 'kv')
+export const d1Path = join(_root, wranglerPath, 'd1')
+export const r2Path = join(_root, wranglerPath, 'r2')
+export const doPath = join(_root, wranglerPath, 'durable_objects')
 
+export function createMiniflare(opts = {}) {
+  const entry = join(_root, opts?.main || opts?.script)
   return new Miniflare({
-    host: options.host || 'localhost',
-    port: options.port || 8787,
-    https: options.https || false,
-    httpsKey: options.httpsKey,
-    httpsCert: options.httpsCert,
-    liveReload: options.liveReload !== false,
+    host: opts.host || 'localhost',
+    port: opts.port || 8787,
+    https: opts.https || false,
+    httpsKey: opts.httpsKey,
+    httpsCert: opts.httpsCert,
+    liveReload: opts.liveReload !== false,
     updateCheck: false,
-
-    scriptPath: join(_root, dist +'/index.js'),
-    compatibilityDate: config.compatibility_date || '2024-11-01',
-    compatibilityFlags: config.compatibility_flags || [
+    scriptPath: entry,
+    modules: [
+      {type: 'ESModule', path: entry},
+    ],
+    compatibilityDate: opts.compatibility_date || '2024-11-01',
+    compatibilityFlags: opts.compatibility_flags || [
       'nodejs_compat',
     ],
-
     bindings: {
-      // MY_VARIABLE: 'value',
-      // ENVIRONMENT: 'development',
-      ...config.vars,
+      ...opts.vars,
     },
 
-    d1Databases: Array.isArray(config.d1_databases) ? Object.fromEntries(config.d1_databases.map(db => [db.binding, db.database_id])) : {},
+    d1Databases: Array.isArray(opts.d1_databases) ? Object.fromEntries(opts.d1_databases.map(db => [db.binding, db.database_id])) : {},
+    kvNamespaces: Object.fromEntries((opts.kv_namespaces || []).map(ns => [ns.binding, ns.id])),
+    // r2Buckets: Object.fromEntries((opts.r2_buckets || []).map(r2 => [r2.binding, r2.bucket_name])),
+    // durableObjects: Object.fromEntries((opts.durable_objects?.bindings || []).map(do => [do.name, do.class_name])),
 
-    modules: [
-      { type: 'ESModule', path: dist +'/index.js' },
-    ],
-    // modules: true,
-    // modulesRules: [
-    //   { type: 'ESModule', include: ['**/*.js', '**/*.ts'] },
-    // ],
-
-    kvPersist: join(_root, '.wrangler/state/v3/kv'),
-    cachePersist: join(_root, '.wrangler/state/v3/cache'),
-    d1Persist: join(_root, '.wrangler/state/v3/d1'),
-    r2Persist: join(_root, '.wrangler/state/v3/r2'),
-    durablesPersist: join(_root, '.wrangler/state/v3/durable_objects'),
+    kvPersist: kvPath,
+    cachePersist: join(_root, wranglerPath, 'cache'),
+    d1Persist: d1Path,
+    r2Persist: r2Path,
+    durablesPersist: doPath,
 
     verbose: false,
 
@@ -240,23 +300,21 @@ export async function createMiniflare(options = {}, configPath = 'wrangler.toml'
     // }),
 
     cfFetch: false, // disable cf requests
-    upstream: config.upstream || 'https://example.com',
+    upstream: opts.upstream || 'https://example.com',
 
-    sitePath: config.site?.bucket ?
-      join(_root, config.site.bucket) : undefined,
-    siteInclude: config.site?.include || ['**/*'],
-    siteExclude: config.site?.exclude || [],
+    sitePath: opts.site?.bucket ?
+      join(_root, opts.site.bucket) : undefined,
+    siteInclude: opts.site?.include || ['**/*'],
+    siteExclude: opts.site?.exclude || [],
 
     globalAsyncIO: true,
     globalTimers: true,
     globalRandom: true,
 
-    inspectorPort: options.inspectorPort || 9229,
+    inspectorPort: opts.inspectorPort || 9229,
 
     cache: true,
     cacheWarnUsage: true,
-
-    ...options
   })
 }
 
@@ -285,8 +343,8 @@ export async function watch(cb: (e: ChokidarEventName | string, file: string) =>
 		join(_root, '{actions,features,routes,configs,enums,libs,locales,middlewares,models,utils}/**/*.ts'),
 		join(_root, '.env.dev'),
 		join(_root, '.env.prod'),
-		join(_root, 'package.json'),
-		join(_root, 'wrangler.toml'),
+    join(_root, 'package.json'),
+    ...WRANGLER_CONFIG_FILES.map(f => join(_root, f)),
 	], {
 		ignored: /(^|[/\\])\../, // ignore hidden files
 		persistent: true,