@atomservice/functions-cli 0.1.6 → 0.1.8

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/index.ts

@@ -10,7 +10,6 @@ import { loginCommand } from "./commands/login.ts"
 import { logoutCommand } from "./commands/logout.ts"
 import { logsCommand } from "./commands/logs.ts"
 import { memberCommand } from "./commands/member.ts"
-import { newCommand } from "./commands/new.ts"
 import { projectCommand } from "./commands/project.ts"
 import { pullCommand } from "./commands/pull.ts"
 import { pushCommand } from "./commands/push.ts"
@@ -34,7 +33,6 @@ export const mainCommand = defineCommand({
     function: functionCommand,
     push: pushCommand,
     pull: pullCommand,
-    new: newCommand,
     dev: devCommand,
     deploy: deployCommand,
     list: listCommand,

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,13 +45,14 @@ export interface BundleConfig {
   cpus?: number
   maxConcurrency?: number
   defaults?: FunctionFileConfig
-  functions?: string[]
   env?: Record<string, string>
+  dev?: { port?: number }
 }
 
 export interface DeployManifest {
   project: string
   bundle: string
+  arch: string
   version: string
   artifact: "binary" | "image"
   functions: string[]
@@ -70,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("已取消")

package/src/commands/new.ts

@@ -1,68 +0,0 @@
-import path from "node:path"
-import { intro, log, outro, select } from "@clack/prompts"
-import { defineCommand } from "citty"
-import pc from "picocolors"
-import { BUNDLE_FILE } from "../consts.ts"
-import { loadContext } from "../context.ts"
-import { scaffoldBundle, scaffoldContainerfile, scaffoldFunction } from "../scaffold.ts"
-import type { BundleConfig, Language } from "../types.ts"
-import { isValidSlug, parseRef, readJson, unwrap } from "../utils.ts"
-
-export const newCommand = defineCommand({
-  meta: { name: "new", description: "创建函数包（bundle）或函数（function）" },
-  args: {
-    ref: { type: "positional", description: "<bundle> 或 <bundle>/<function>", required: true },
-    lang: { type: "string", description: "语言：bun（默认）" },
-    "with-containerfile": { type: "boolean", description: "生成逃生舱 Containerfile 模板" },
-  },
-  async run({ args }) {
-    intro(pc.cyan("创建脚手架"))
-    const ctx = await loadContext()
-    if (!ctx) {
-      log.error("未找到 atomfunctions.json")
-      process.exit(1)
-    }
-    const { bundle, fn } = parseRef(args.ref)
-
-    if (!isValidSlug(bundle)) {
-      log.error("bundle 名需以小写字母开头，仅含小写字母、数字、连字符")
-      process.exit(1)
-    }
-
-    const bundleDir = path.join(ctx.root, bundle)
-    const existingConfig = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
-
-    let language: Language = existingConfig?.language ?? "bun"
-    if (!existingConfig) {
-      language = (args.lang ??
-        unwrap(
-          await select({
-            message: "选择语言",
-            options: [
-              { value: "bun", label: "Bun (TypeScript)" },
-              { value: "rust", label: "Rust" },
-            ],
-            initialValue: "bun",
-          }),
-        )) as Language
-      await scaffoldBundle(bundleDir, { language })
-      log.success(`已创建 bundle ${bundle}`)
-    }
-
-    if (args["with-containerfile"]) {
-      await scaffoldContainerfile(bundleDir)
-      log.success("已生成逃生舱 Containerfile")
-    }
-
-    if (fn) {
-      if (!isValidSlug(fn)) {
-        log.error("function 名需以小写字母开头，仅含小写字母、数字、连字符")
-        process.exit(1)
-      }
-      await scaffoldFunction(bundleDir, fn, language)
-      log.success(`已创建函数 ${bundle}/${fn}`)
-    }
-
-    outro(pc.green("完成，运行 atomfunctions deploy 进行部署"))
-  },
-})