create-feltdb 0.6.9 → 0.6.11

package/dist/server-source/crates/feltdb-server/src/main.rs

@@ -41,6 +41,7 @@ use feltdb::{
         Grant, GrantSigner, GrantStore, Subject as GrantSubject,
     },
     cardinality_endpoint::{CardinalityContext, CardinalityDiagnosticResponse},
+    AtomicMutation, AtomicPrecondition,
     policy_evaluation::{Actor, PolicyContext, PolicyEvaluator, PolicySubject},
     state_contract::{
         begin_read, compare_schemas, execute_query as execute_state_query, execute_transaction,
@@ -6298,6 +6299,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "/api/connections/{connection_id}",
             axum::routing::delete(delete_connection_control),
         )
+        .route("/transactions", axum::routing::post(commit_transaction))
+        .route("/revision", get(get_revision))
         .route(
             "/collections/{collection}",
             get(list_records).post(create_record),
@@ -8974,6 +8977,30 @@ fn put_canonical(
     }))
 }
 
+/// The authority's current committed-state revision.
+///
+/// This is the value `apply_atomic_transaction` advances and writes into each
+/// durable transaction record as `state_after`. It already survived restart and
+/// already refused to move backwards; the only thing missing was a way to read
+/// it without performing a write, which is what a cache needs.
+///
+/// `scope` is the store's instance id. A revision is comparable only against
+/// another revision carrying the same scope, so a client that fails over to a
+/// different replica sees a scope change rather than a silently wrong
+/// comparison against a counter that means something else there.
+#[derive(Serialize)]
+struct RevisionResponse {
+    revision: u64,
+    scope: String,
+}
+
+async fn get_revision(State(state): State<AppState>) -> Result<Json<RevisionResponse>, ApiError> {
+    Ok(Json(RevisionResponse {
+        revision: state.db.sequence()?,
+        scope: state.db.instance_id()?,
+    }))
+}
+
 async fn list_records(
     State(state): State<AppState>,
     Path(collection): Path<String>,
@@ -9000,6 +9027,120 @@ async fn get_record(
     }))
 }
 
+/// One operation inside an application transaction.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AtomicTxOperationRequest {
+    collection: String,
+    id: String,
+    /// Absent value means delete.
+    #[serde(default)]
+    value: Option<Map<String, Value>>,
+    /// When set, the record must not already exist for the transaction to commit.
+    #[serde(default)]
+    require_absent: bool,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AtomicTxRequest {
+    /// Caller-supplied identity. Reusing one makes the commit idempotent.
+    transaction_id: String,
+    operations: Vec<AtomicTxOperationRequest>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct AtomicTxResponse {
+    transaction_id: String,
+    /// True when this id had already been committed; nothing was reapplied.
+    duplicate: bool,
+    operations: usize,
+    state_before: u64,
+    state_after: u64,
+}
+
+/// Commit several operations as one atomic, durable transaction.
+///
+/// This is the application-facing entry point to the same atomic commit path
+/// the substrate uses: preconditions are evaluated first, then one transaction
+/// record is written and fsynced, and only then is derived state updated.
+/// There is no second transaction mechanism — the request is translated into
+/// the store's own atomic transaction and nothing else.
+async fn commit_transaction(
+    State(state): State<AppState>,
+    Json(request): Json<AtomicTxRequest>,
+) -> Result<(StatusCode, Json<AtomicTxResponse>), ApiError> {
+    if request.transaction_id.trim().is_empty() {
+        return Err(ApiError(
+            StatusCode::BAD_REQUEST,
+            "transactionId is required".to_string(),
+        ));
+    }
+    if request.operations.is_empty() {
+        return Err(ApiError(
+            StatusCode::BAD_REQUEST,
+            "a transaction requires at least one operation".to_string(),
+        ));
+    }
+
+    // Validate every operation before any of them is turned into a mutation, so
+    // a malformed request cannot commit a prefix of the transaction.
+    let mut mutations = Vec::with_capacity(request.operations.len());
+    let mut preconditions = Vec::new();
+    let mut seen = std::collections::HashSet::new();
+    for operation in request.operations {
+        let key = record_key(&operation.collection, &operation.id)?;
+        if !seen.insert(key.clone()) {
+            return Err(ApiError(
+                StatusCode::BAD_REQUEST,
+                format!("transaction writes {key} more than once"),
+            ));
+        }
+        if operation.require_absent {
+            // The store reads a precondition with no expected version as
+            // "this record must not exist", and evaluates it inside the same
+            // lock as the commit, so there is no window between the check and
+            // the write.
+            preconditions.push(AtomicPrecondition {
+                capability: operation.collection.clone(),
+                key: key.clone(),
+                expected_version: None,
+            });
+        }
+        let value = operation.value.map(|mut fields| {
+            fields.insert("id".to_string(), Value::String(operation.id.clone()));
+            Value::Object(fields)
+        });
+        mutations.push(AtomicMutation {
+            capability: operation.collection,
+            key,
+            value,
+        });
+    }
+
+    let operations = mutations.len();
+    let commit = state
+        .db
+        .apply_atomic_transaction(&request.transaction_id, None, &preconditions, &mutations, None)
+        .map_err(|error| {
+            // A refused transaction applied nothing, so this is a conflict, not
+            // a partially completed request.
+            ApiError(StatusCode::CONFLICT, error.to_string())
+        })?;
+
+    Ok((
+        if commit.duplicate { StatusCode::OK } else { StatusCode::CREATED },
+        Json(AtomicTxResponse {
+            transaction_id: commit.transaction_id,
+            duplicate: commit.duplicate,
+            operations,
+            state_before: commit.state_before,
+            state_after: commit.state_after,
+        }),
+    ))
+}
+
 async fn create_record(
     State(state): State<AppState>,
     Path(collection): Path<String>,

package/dist/workspace-initialization.js

@@ -7,14 +7,13 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { randomBytes } from 'crypto';
 /**
  * Generate a unique workspace ID
- * Format: ws_<projectId>_<timestamp>_<random>
+ * Opaque format: ws_<random>. Project identity is stored separately.
  */
-export function generateWorkspaceId(projectId) {
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substring(2, 9);
-    return `ws_${projectId}_${timestamp}_${random}`;
+export function generateWorkspaceId(_projectId) {
+    return `ws_${randomBytes(16).toString('hex')}`;
 }
 /**
  * Initialize development workspace for a new project

package/package.json

@@ -2,7 +2,7 @@
   "name": "create-feltdb",
   "private": false,
   "description": "Create a new FeltDB application with one command",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "license": "MIT",
   "bin": {
     "create-feltdb": "bin/create-feltdb.js"