build

type Artifact ¶

type Artifact = buildmanifest.Artifact

The build manifest wire types are defined once in the public buildmanifest package (the single source of truth shared with the Celerity transformer) and re-exported here as aliases so existing internal/build call sites are unchanged.

type ArtifactUploader ¶

type ArtifactUploader interface {
	Upload(ctx context.Context, artifact *Artifact, key string) error
	UploadManifest(ctx context.Context, data []byte, instanceName string) (string, error)
}

ArtifactUploader uploads build artifacts to remote storage.

func ResolveUploader(deployTarget string, providerConfig map[string]any) ArtifactUploader

type BuildParams ¶

type BuildParams struct {
	AppDir              string
	Runtime             string
	DeployTarget        string
	Handlers            []HandlerInfo
	HandlerDependencies map[string][]string
	OutputDir           string
	Uploader            ArtifactUploader
	InstanceName        string
	Logger              *zap.Logger
	// Blueprint is the merged blueprint used to derive build-time artifacts
	// like the resource links file bundled into the Lambda app archive.
	Blueprint *schema.Blueprint
	// ToolOutput is the writer for tool output (npm, pip, tsc).
	// In interactive mode this should be a log file; in headless/standalone
	// mode it should be os.Stdout.
	ToolOutput io.Writer
	// Toolchain builds the handlers executable for an OS-only runtime, and is
	// nil for a runtime that hosts the language itself. Its presence is what
	// selects the compiled packaging path.
	Toolchain handlertoolchain.Toolchain
}

BuildParams holds the inputs needed to execute a build.

type CommandExecutor ¶

type CommandExecutor interface {
	Run(ctx context.Context, dir string, toolOutput io.Writer, name string, args ...string) error
}

CommandExecutor runs external commands. The default implementation uses os/exec; tests can substitute a stub.

type DependencyInstaller ¶

type DependencyInstaller interface {
	InstallDependencies(ctx context.Context, appDir, targetDir string, packages []string, toolOutput io.Writer) error
}

DependencyInstaller installs dependencies into a target directory. When packages is nil, all production dependencies are installed. When packages is non-nil, only those packages are installed. toolOutput receives tool stdout/stderr (npm, pip output).

type ExecCommandExecutor ¶

type ExecCommandExecutor struct{}

ExecCommandExecutor is the default CommandExecutor that shells out to external tools via os/exec.

func (e *ExecCommandExecutor) Run(
	ctx context.Context,
	dir string,
	toolOutput io.Writer,
	name string,
	args ...string,
) error

type HandlerArtifacts ¶

type HandlerArtifacts = buildmanifest.HandlerArtifacts

The build manifest wire types are defined once in the public buildmanifest package (the single source of truth shared with the Celerity transformer) and re-exported here as aliases so existing internal/build call sites are unchanged.

type HandlerBootstrap ¶

type HandlerBootstrap interface {
	Generate(stagingDir string) (entryPoint string, err error)

	// RequiredPackage names the adapter package the generated entry file
	// imports, so the build can check the app actually depends on it.
	//
	// Declared here rather than checked elsewhere because the import and the
	// requirement have to move together. A bootstrap whose import changed
	// while a check somewhere else kept naming the old package would produce
	// handlers that provision cleanly and then fail on their first
	// invocation, a long way from the mistake.
	RequiredPackage() string
}

HandlerBootstrap writes a per-language entry point file that wraps the developer's app in the appropriate Celerity SDK serverless adapter for the deploy target. Returns the entry point string that the strategy should record on its target-specific sub-manifest.

Generate is called once per build rather than once per handler, since the bootstrap is identical across all handlers in a project and the shared app code bundle contains a single copy of it.

Implementations are strategy-specific (e.g. LambdaNodeBootstrap wraps the app for AWS Lambda). A future GCP strategy would ship its own implementations targeting the GCP serverless adapter.

type HandlerDependencyReader ¶

type HandlerDependencyReader interface {
	ReadHandlerDependencies(appDir string) (map[string][]string, error)
}

HandlerDependencyReader reads per-handler dependency declarations from a language-specific manifest file.

type HandlerInfo ¶

type HandlerInfo struct {
	ResourceName string
	HandlerName  string
	CodeLocation string
}

HandlerInfo describes a handler to be built.

type LambdaHandlerArtifacts ¶

type LambdaHandlerArtifacts = buildmanifest.LambdaHandlerArtifacts

The build manifest wire types are defined once in the public buildmanifest package (the single source of truth shared with the Celerity transformer) and re-exported here as aliases so existing internal/build call sites are unchanged.

type LambdaManifest ¶

type LambdaManifest = buildmanifest.LambdaManifest

The build manifest wire types are defined once in the public buildmanifest package (the single source of truth shared with the Celerity transformer) and re-exported here as aliases so existing internal/build call sites are unchanged.

type LambdaNodeBootstrap ¶

type LambdaNodeBootstrap struct {
	AppDir string
}

LambdaNodeBootstrap is the Lambda-specific HandlerBootstrap for Node.js. It wraps the developer's app in the Celerity Node SDK's AWS Lambda adapter.

The generated file imports from the `/handler` subpath of @celerity-sdk/serverless-aws rather than the package root so only the lean entry module is pulled in at cold start, not the full package index.

func (n *LambdaNodeBootstrap) Generate(stagingDir string) (string, error)

func (n *LambdaNodeBootstrap) RequiredPackage() string

type LambdaPythonBootstrap ¶

type LambdaPythonBootstrap struct{}

LambdaPythonBootstrap is the Lambda-specific HandlerBootstrap for Python. It wraps the developer's app in the Celerity Python SDK's AWS Lambda adapter (celerity.serverless.aws.create_lambda_handler).

func (p *LambdaPythonBootstrap) Generate(stagingDir string) (string, error)

func (p *LambdaPythonBootstrap) RequiredPackage() string

type LambdaStrategy ¶

type LambdaStrategy struct {
	Registry *Registry
	// Bootstraps maps runtime prefixes (e.g. "nodejs", "python") to the
	// Lambda-specific handler bootstrap for that language. Kept on the
	// strategy rather than the shared registry because bootstraps are
	// deploy-target-specific, and a future GCP strategy would ship its own
	// mapping with different SDK imports.
	Bootstraps map[string]HandlerBootstrap
}

LambdaStrategy packages a Celerity application for AWS Lambda as a single shared app code bundle (referenced by every handler's Lambda function) plus a shared or per-handler dependency layer. Per-handler dep layers are opt-in via handlerDependencies declarations in the developer's package manifest.

func (s *LambdaStrategy) Build(ctx context.Context, params *BuildParams) (*Manifest, error)

type Manifest ¶

type Manifest = buildmanifest.Manifest

The build manifest wire types are defined once in the public buildmanifest package (the single source of truth shared with the Celerity transformer) and re-exported here as aliases so existing internal/build call sites are unchanged.

func ReadManifest() (*Manifest, error)

type NodeDependencyInstaller ¶

type NodeDependencyInstaller struct {
	Exec CommandExecutor
	PM   NodePackageManager
}

NodeDependencyInstaller installs Node.js production dependencies using the project's package manager.

func (n *NodeDependencyInstaller) InstallDependencies(
	ctx context.Context,
	appDir string,
	targetDir string,
	packages []string,
	toolOutput io.Writer,
) error

type NodeHandlerDependencyReader ¶

type NodeHandlerDependencyReader struct{}

NodeHandlerDependencyReader reads celerity.handlerDependencies from package.json.

func (r *NodeHandlerDependencyReader) ReadHandlerDependencies(appDir string) (map[string][]string, error)

type NodePackageManager ¶

type NodePackageManager string

NodePackageManager represents a detected Node.js package manager.

const (
	NodePMNpm  NodePackageManager = "npm"
	NodePMYarn NodePackageManager = "yarn"
	NodePMPnpm NodePackageManager = "pnpm"
)

func DetectNodePackageManager(appDir string) NodePackageManager

func (pm NodePackageManager) ExecPrefix() []string

func (pm NodePackageManager) InstallCommand() []string

func (pm NodePackageManager) LockFiles() []string

type NodeSourceCompiler ¶

type NodeSourceCompiler struct {
	Exec CommandExecutor
	PM   NodePackageManager
}

NodeSourceCompiler compiles TypeScript source to JavaScript using tsc, preserving the directory structure for readability in cloud provider consoles. If no tsconfig.json is found, it assumes the project is plain JavaScript and does nothing.

func (c *NodeSourceCompiler) Compile(
	ctx context.Context,
	srcDir string,
	outDir string,
	toolOutput io.Writer,
) error

type PythonDependencyInstaller ¶

type PythonDependencyInstaller struct {
	Exec CommandExecutor
}

PythonDependencyInstaller installs Python production dependencies using pip.

func (p *PythonDependencyInstaller) InstallDependencies(
	ctx context.Context,
	appDir string,
	targetDir string,
	packages []string,
	toolOutput io.Writer,
) error

type PythonHandlerDependencyReader ¶

type PythonHandlerDependencyReader struct{}

PythonHandlerDependencyReader reads [tool.celerity.handlerDependencies] from pyproject.toml.

func (r *PythonHandlerDependencyReader) ReadHandlerDependencies(appDir string) (map[string][]string, error)

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

Registry holds build components keyed by deploy target or runtime prefix.

func NewDefaultRegistry(appDir string) *Registry

func NewRegistry() *Registry

func NewRegistryWithExecutor(exec CommandExecutor, appDir string) *Registry

func (r *Registry) GetDependencyInstaller(runtime string) (DependencyInstaller, error)

func (r *Registry) GetHandlerDependencyReader(runtime string) HandlerDependencyReader

func (r *Registry) GetSourceCompiler(runtime string) SourceCompiler

func (r *Registry) GetStrategy(deployTarget string) (Strategy, error)

func (r *Registry) RegisterDependencyInstaller(runtimePrefix string, i DependencyInstaller)

func (r *Registry) RegisterHandlerDependencyReader(runtimePrefix string, reader HandlerDependencyReader)

func (r *Registry) RegisterSourceCompiler(runtimePrefix string, c SourceCompiler)

func (r *Registry) RegisterStrategy(deployTarget string, s Strategy)

type S3ArtifactUploader ¶

type S3ArtifactUploader struct {
	// contains filtered or unexported fields
}

S3ArtifactUploader uploads build artifacts to an S3 bucket. The bucket is auto-created with a conventional name if it doesn't exist.

func (u *S3ArtifactUploader) Upload(ctx context.Context, artifact *Artifact, key string) error

func (u *S3ArtifactUploader) UploadManifest(
	ctx context.Context, data []byte, instanceName string,
) (string, error)

type SourceCompiler ¶

type SourceCompiler interface {
	Compile(ctx context.Context, srcDir, outDir string, toolOutput io.Writer) error
}

SourceCompiler compiles or transpiles source code for deployment, preserving the directory structure for readability. toolOutput receives compiler stdout/stderr (tsc output).

type Strategy ¶

type Strategy interface {
	Build(ctx context.Context, params *BuildParams) (*Manifest, error)
}

Strategy determines how an application is packaged for a given deploy target.