@atomservice/functions-cli 0.1.7 → 0.1.9

package/src/context.ts

@@ -57,12 +57,17 @@ export async function requireServerContext(): Promise<CliContext> {
   }
 
   const servers = resolveServers(ctx.manifest)
-  const targets: ServerTarget[] = []
-  for (const server of servers) {
-    const host = hostOf(server)
-    const cred = await getCredential(host)
-    if (cred) targets.push({ server, host, token: cred.token })
-  }
+  const creds = await Promise.all(
+    servers.map(async (server) => {
+      const host = hostOf(server)
+      const cred = await getCredential(host)
+      return { server, host, token: cred?.token ?? null }
+    }),
+  )
+  const fallbackToken = creds.find((c) => c.token)?.token
+  const targets: ServerTarget[] = creds
+    .filter((c) => c.token || fallbackToken)
+    .map((c) => ({ server: c.server, host: c.host, token: (c.token || fallbackToken)! }))
 
   return { ...ctx, targets }
 }

package/src/scaffold.ts

@@ -1,5 +1,6 @@
 import path from "node:path"
-import { BUNDLE_FILE, FUNCTION_CONFIG_FILE, FUNCTION_FILE, SDK_PACKAGE } from "./consts.ts"
+import { snakeCase } from "change-case"
+import { BUNDLE_FILE, FUNCTION_CONFIG_FILE, FUNCTION_FILE, RUST_SDK_VERSION, SDK_PACKAGE } from "./consts.ts"
 import type { BundleConfig, FunctionKind, Language } from "./types.ts"
 import { ensureDir, writeJson } from "./utils.ts"
 
@@ -87,9 +88,12 @@ export async function scaffoldFunction(
   kind: FunctionKind = "function",
 ): Promise<void> {
   if (language === "rust") {
-    const fnPath = path.join(bundleDir, "src", "functions", `${fn}.rs`)
-    ensureDir(path.dirname(fnPath))
-    await Bun.write(fnPath, rustFunctionSource(fn))
+    const fnDir = path.join(bundleDir, "src", "functions", fn)
+    const fnPath = path.join(fnDir, "function.rs")
+    ensureDir(fnDir)
+    await Bun.write(fnPath, rustFunctionSource(snakeCase(fn)))
+    await writeJson(path.join(fnDir, FUNCTION_CONFIG_FILE), {})
+    await rustAutoRegister(bundleDir, fn)
     return
   }
   const fnDir = path.join(bundleDir, fn)
@@ -109,47 +113,30 @@ name = ${JSON.stringify(bundle)}
 path = "src/main.rs"
 
 [dependencies]
-atomfunctions = "0.0.1"
+atomfn = "${RUST_SDK_VERSION}"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+validator = { version = "0.19", features = ["derive"] }
 `
 }
 
 function rustMainSource(): string {
-  return `use atomfunctions::{serve, Ctx, FunctionError, Registry};
-use serde::{Deserialize, Serialize};
-
-#[derive(Deserialize)]
-struct GreetInput {
-    name: String,
-}
-
-#[derive(Serialize)]
-struct GreetOutput {
-    greeting: String,
-}
-
-fn greet(input: GreetInput, ctx: &Ctx) -> Result<GreetOutput, FunctionError> {
-    ctx.info("greeting");
-    Ok(GreetOutput { greeting: format!("hello, {}", input.name) })
-}
+  return `mod functions;
+use atomfn::serve;
+use functions::*;
 
-fn main() {
-    let mut registry = Registry::new();
-    registry.function("greet", greet);
-    serve(registry);
-}
+serve! {}
 `
 }
 
-function rustFunctionSource(fn: string): string {
-  return `// 函数 ${fn}：在 src/main.rs 中用 registry.function("${fn}", ${fn}) 注册，
-// 并在 ${BUNDLE_FILE} 的 functions 数组中加入 "${fn}"。
-use atomfunctions::{Ctx, FunctionError};
+function rustFunctionSource(rustName: string): string {
+  return `use atomfn::{Ctx, FunctionError};
 use serde::{Deserialize, Serialize};
+use validator::Validate;
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Validate)]
 pub struct Input {
+    #[validate(length(min = 1, max = 100))]
     pub name: String,
 }
 
@@ -158,33 +145,62 @@ pub struct Output {
     pub greeting: String,
 }
 
-pub fn ${fn}(input: Input, _ctx: &Ctx) -> Result<Output, FunctionError> {
+pub fn ${rustName}(input: Input, _ctx: &Ctx) -> Result<Output, FunctionError> {
     Ok(Output { greeting: format!("hello, {}", input.name) })
 }
 `
 }
 
-function rustContainerfile(bundle: string): string {
-  return `FROM rust:1-slim AS builder
-WORKDIR /build
-COPY . .
-RUN cargo build --release
+async function rustAutoRegister(bundleDir: string, slug: string): Promise<void> {
+  const rustName = snakeCase(slug)
 
-FROM debian:bookworm-slim
+  const modPath = path.join(bundleDir, "src", "functions", "mod.rs")
+  const modContent = await Bun.file(modPath)
+    .text()
+    .catch(() => "")
+  const modDecl = `#[path = "${slug}/function.rs"]
+pub mod ${rustName};
+pub use ${rustName}::*;`
+  if (!modContent.includes(`pub mod ${rustName};`)) {
+    const newMod = modContent.trimEnd() ? `${modContent.trimEnd()}\n${modDecl}\n` : `${modDecl}\n`
+    await Bun.write(modPath, newMod)
+  }
+
+  const mainPath = path.join(bundleDir, "src", "main.rs")
+  const mainContent = await Bun.file(mainPath).text()
+  const macroMatch = mainContent.match(/serve!\s*\{([^}]*)\}/)
+  if (!macroMatch) return
+
+  const body = macroMatch[1] ?? ""
+  const entryRegex = /(stream\s+)?([a-z][a-z0-9_]*)/g
+  for (let match = entryRegex.exec(body); match !== null; match = entryRegex.exec(body)) {
+    if (match[2] === rustName) return
+  }
+
+  const entries = body.trim() ? `${body.trim()}, ${rustName}` : rustName
+  const newMain = mainContent.replace(/serve!\s*\{[^}]*\}/, `serve! { ${entries} }`)
+  await Bun.write(mainPath, newMain)
+}
+
+function rustContainerfile(): string {
+  return `FROM debian:bookworm-slim
 RUN apt-get update \\
     && apt-get install -y --no-install-recommends ca-certificates \\
     && rm -rf /var/lib/apt/lists/*
-COPY --from=builder /build/target/release/${bundle} /app/bundle
+WORKDIR /app
+COPY bundle /app/bundle
+COPY functions.config.json /app/functions.config.json
 ENTRYPOINT ["/app/bundle"]
 `
 }
 
 async function scaffoldRustBundle(bundleDir: string, config: BundleConfig): Promise<void> {
   const bundle = path.basename(bundleDir)
-  await writeJson(path.join(bundleDir, BUNDLE_FILE), { ...config, functions: config.functions ?? ["greet"] })
+  await writeJson(path.join(bundleDir, BUNDLE_FILE), config)
   await Bun.write(path.join(bundleDir, "Cargo.toml"), rustCargoToml(bundle))
-  await Bun.write(path.join(bundleDir, "Containerfile"), rustContainerfile(bundle))
+  await Bun.write(path.join(bundleDir, "Containerfile"), rustContainerfile())
   await Bun.write(path.join(bundleDir, "src", "main.rs"), rustMainSource())
+  await Bun.write(path.join(bundleDir, "src", "functions", "mod.rs"), "")
   await Bun.write(path.join(bundleDir, ".gitignore"), "target/\n.atomfn-*\n")
 }
 

package/src/types.ts

@@ -45,7 +45,6 @@ export interface BundleConfig {
   cpus?: number
   maxConcurrency?: number
   defaults?: FunctionFileConfig
-  functions?: string[]
   env?: Record<string, string>
   dev?: { port?: number }
 }
@@ -53,6 +52,7 @@ export interface BundleConfig {
 export interface DeployManifest {
   project: string
   bundle: string
+  arch: string
   version: string
   artifact: "binary" | "image"
   functions: string[]
@@ -71,6 +71,7 @@ export interface BundleRecord {
   host: string
   port: number
   functions: string[]
+  arch: string
   version: string
   artifact: "binary" | "image"
   image: string

package/src/utils.ts

@@ -26,6 +26,11 @@ export function isValidSlug(slug: string): boolean {
   return SLUG_RE.test(slug)
 }
 
+export function bunTarget(arch: string): string {
+  if (arch === "arm64") return "bun-linux-arm64"
+  return "bun-linux-x64"
+}
+
 export function unwrap<T>(value: T | symbol): T {
   if (isCancel(value)) {
     cancel("已取消")