84833d3e4e
Lays down the v1.1.3 plumbing:
- `ScriptKind` enum in `picloud-shared` ('endpoint' | 'module').
- `ModuleSource` trait + `ModuleScript` DTO + `NoopModuleSource` in
`picloud-shared`. Resolver lives in `executor-core`; Postgres impl
in `manager-core` (`PostgresModuleSource`).
- `Services::new` grows a fifth `modules: Arc<dyn ModuleSource>` arg.
- `ScriptValidator` returns `ValidatedScript { imports }` so the
manager can populate the dep-graph table on save. New
`validate_module` method on the trait gates module-shape rules.
- `Engine::execute_ast(&Arc<rhai::AST>, req)` lets the orchestrator's
script cache reuse compiled ASTs. `Engine::execute(&str, req)` is
preserved as a convenience that compiles inline. `Engine::compile`
exposes the AST for callers that want to cache.
- `PicloudModuleResolver` replaces `DummyModuleResolver` per-call.
Bridges Rhai's sync `ModuleResolver::resolve` to async
`ModuleSource::lookup` via `Handle::block_on`. Enforces:
- cross-app isolation (resolver captures `Arc<SdkCallCx>`),
- circular import detection (in-progress stack on the resolver),
- import depth limit (default 8 via
`Limits::module_import_depth_max`).
- Module-shape validation walks `ast.statements()` via `rhai/internals`
and accepts only `Var { CONSTANT }`, `Import`, and `Noop`. The
manager admin endpoint runs `validate_module` at save (primary
gate); resolver re-runs it at load (defense in depth).
- LRU cache `(AppId, name) -> (updated_at, Arc<Module>)` owned by
`Engine`. Size from `PICLOUD_MODULE_CACHE_SIZE` (default 512).
- Migration `0015_scripts_kind.sql` adds `scripts.kind` + composite
index + module-name shape CHECK.
- Migration `0016_script_imports.sql` adds the dep-graph table with
FK CASCADE on both columns.
- Repo: `kind` threaded through SELECT/INSERT/UPDATE. New
`count_routes_for_script` / `count_triggers_for_script` /
`list_imports` methods. `create`/`update` open a transaction and
call `replace_imports_tx` to populate the dep-graph.
- Admin endpoint: accepts `kind`; rejects reserved module names;
rejects `endpoint → module` transitions when routes / triggers
exist.
- SDK_VERSION 1.3 → 1.4.
Workspace builds; full test suite (~440 tests) green.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
96 lines
3.1 KiB
Rust
96 lines
3.1 KiB
Rust
//! Hello-World seed for fresh installs.
|
|
//!
|
|
//! Idempotent. Runs after migrations and after admin bootstrap. Only
|
|
//! seeds when the default app is empty (no scripts, no routes); on
|
|
//! upgrades it does nothing so existing content isn't polluted.
|
|
|
|
use std::sync::Arc;
|
|
|
|
use picloud_shared::{App, AppId, HostKind, PathKind};
|
|
|
|
use crate::app_repo::AppRepository;
|
|
use crate::repo::{NewScript, ScriptRepository, ScriptRepositoryError};
|
|
use crate::route_repo::{NewRoute, RouteRepository};
|
|
|
|
const HELLO_RHAI_SOURCE: &str = include_str!("../seeds/hello.rhai");
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum HelloWorldOutcome {
|
|
/// Default app already has scripts (or doesn't exist) — left alone.
|
|
SkippedExisting,
|
|
/// Inserted the hello.rhai script and the `/hello` route.
|
|
Seeded,
|
|
}
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum SeedError {
|
|
#[error("default app not found — did the migration run?")]
|
|
MissingDefaultApp,
|
|
#[error("repository error: {0}")]
|
|
Repo(#[from] ScriptRepositoryError),
|
|
}
|
|
|
|
pub async fn seed_hello_world_if_fresh(
|
|
apps: Arc<dyn AppRepository>,
|
|
scripts: Arc<dyn ScriptRepository>,
|
|
routes: Arc<dyn RouteRepository>,
|
|
) -> Result<HelloWorldOutcome, SeedError> {
|
|
let default = apps
|
|
.get_by_slug("default")
|
|
.await?
|
|
.ok_or(SeedError::MissingDefaultApp)?;
|
|
|
|
// Idempotence: only seed when both scripts AND routes are empty.
|
|
// (Either alone is suspicious enough to skip — the operator may have
|
|
// already started shaping the default app.)
|
|
let existing_scripts = scripts.list_for_app(default.id).await?;
|
|
let existing_routes = routes.list_for_app(default.id).await?;
|
|
if !existing_scripts.is_empty() || !existing_routes.is_empty() {
|
|
return Ok(HelloWorldOutcome::SkippedExisting);
|
|
}
|
|
|
|
seed_into(&*scripts, &*routes, &default).await?;
|
|
Ok(HelloWorldOutcome::Seeded)
|
|
}
|
|
|
|
async fn seed_into(
|
|
scripts: &dyn ScriptRepository,
|
|
routes: &dyn RouteRepository,
|
|
default: &App,
|
|
) -> Result<(), ScriptRepositoryError> {
|
|
let script = scripts
|
|
.create(NewScript {
|
|
app_id: default.id,
|
|
name: "hello".to_string(),
|
|
description: Some("Reference example: returns a greeting at GET /hello.".to_string()),
|
|
source: HELLO_RHAI_SOURCE.to_string(),
|
|
kind: picloud_shared::ScriptKind::Endpoint,
|
|
timeout_seconds: Some(5),
|
|
memory_limit_mb: None,
|
|
sandbox: None,
|
|
imports: Vec::new(),
|
|
})
|
|
.await?;
|
|
|
|
routes
|
|
.create(NewRoute {
|
|
app_id: default.id,
|
|
script_id: script.id,
|
|
host_kind: HostKind::Any,
|
|
host: String::new(),
|
|
host_param_name: None,
|
|
path_kind: PathKind::Exact,
|
|
path: "/hello".to_string(),
|
|
// Accept any method so both `curl /hello` and
|
|
// `curl -d '{"name":"X"}' /hello` work out of the box.
|
|
method: None,
|
|
dispatch_mode: picloud_shared::DispatchMode::Sync,
|
|
})
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn _typecheck(_id: AppId) {} // suppress unused-import warnings if reshuffled
|