using System.Text.Json; using Generated; using Generated.Models; using TeaQL.Core; using TeaQL.Sql; using TeaQL.Provider.Sqlite; using Microsoft.Data.Sqlite; const string Seed = "Seed the Order workflow fixture"; const string EditReason = "Edit draft Order quantity and totals atomically"; static void Require(bool value, string message) { if (!value) throw new InvalidOperationException(message); } static void Report(string name, object value) => Console.WriteLine("ORDER_CASE " + JsonSerializer.Serialize(new { @case = name, value })); static object Missing(Func call) { try { call(); } catch (TeaQLNotLoadedException error) { return new { type = error.GetType().Name, message = error.Message }; } throw new InvalidOperationException("NotLoaded unexpectedly succeeded"); } static async Task Graph(UserContext context) { var rows = await Q.CustomerOrders().OrderByOrderNumberAscending().OrderByIdAscending() .SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAscending().OrderByIdAscending().Limit(101)).Limit(10) .Comment("Read bounded full Order graphs").Purpose("Verify persisted Order workflow results").ExecuteForListAsync(context); return rows.Select(order => (object)new { orderNumber = E.CustomerOrder(order).OrderNumber().Eval(), totalMinor = E.CustomerOrder(order).TotalMinor().Eval(), note = E.CustomerOrder(order).OrderNote().Eval(), version = E.CustomerOrder(order).Version().Eval(), items = order.OrderItemList.Select(item => new { sku = E.OrderItem(item).SkuCode().Eval(), productName = E.OrderItem(item).ProductName().Eval(), quantity = E.OrderItem(item).Quantity().Eval(), unitPriceMinor = E.OrderItem(item).UnitPriceMinor().Eval(), lineTotalMinor = E.OrderItem(item).LineTotalMinor().Eval(), version = E.OrderItem(item).Version().Eval() }).ToArray() }).ToArray(); } static async Task Edit(UserContext context, double quantity, bool rollback) { if (!double.IsFinite(quantity) || Math.Truncate(quantity) != quantity || quantity < 1 || quantity > 100) throw new ArgumentOutOfRangeException(nameof(quantity), "Quantity must be an integer in [1, 100]"); var rows = await Q.CustomerOrders().WithOrderNumberIs("ORD-2026-1001") .SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAscending().OrderByIdAscending().Limit(101)).Limit(2) .Comment("Load full draft and bounded full items").Purpose("Validate and edit one draft order").ExecuteForListAsync(context); Require(rows.Count == 1, "Expected one order"); var order = rows[0]; Require(E.CustomerOrder(order).OrderStatusId().Eval() == 1001, "Only DRAFT orders can be edited"); Require(E.CustomerOrder(order).CurrencyCode().Eval() == "USD", "Unsupported currency"); Require(order.OrderItemList.Count <= 100, "Order item limit exceeded"); OrderItem? selected = null; long total = 0; checked { foreach (var item in order.OrderItemList) { long price = E.OrderItem(item).UnitPriceMinor().Eval() ?? throw new Exception("Missing price"); long units = E.OrderItem(item).Quantity().Eval() ?? throw new Exception("Missing quantity"); Require(price >= 0 && price <= 100000 && units >= 1 && units <= 100 && E.OrderItem(item).LineTotalMinor().Eval() == price * units, "Invalid persisted item amount"); if (E.OrderItem(item).SkuCode().Eval() == "SKU-NOTEBOOK") { Require(selected is null, "Duplicate SKU"); selected = item; units = (long)quantity; } total += price * units; } Require(selected is not null && total <= 1000000000, "Missing item or invalid total"); var target = selected ?? throw new Exception("Missing item"); if (rollback) { var winner = await Q.OrderItems().WithIdIs(E.OrderItem(target).Id().Eval() ?? throw new Exception("Missing item ID")).Limit(2) .Comment("Load independent item revision").Purpose("Probe atomic rollback on stale child").ExecuteForOneAsync(context) ?? throw new Exception("Missing winner"); winner.UpdateProductName("Notebook (concurrent winner)"); await winner.AuditAs("Advance Order item before stale graph probe").SaveAsync(context); } target.UpdateQuantity((long)quantity); target.UpdateLineTotalMinor((long)quantity * (E.OrderItem(target).UnitPriceMinor().Eval() ?? throw new Exception("Missing price"))); order.UpdateTotalMinor(total); Console.WriteLine("ORDER_GRAPH_ATTEMPT"); await order.AuditAs(EditReason).SaveAsync(context); } } static async Task CompleteRead(UserContext context) { var orders=await Q.CustomerOrders().OrderByOrderNumberAscending().OrderByIdAscending().Limit(10) .Comment("Read authoritative Order states").Purpose("Verify transition persistence after restart").ExecuteForListAsync(context); var deleted=await Q.OrderItems().DeletedRowsOnly().WithSkuCodeIs("SKU-PEN").Limit(10) .Comment("Read retained deleted Order lines").Purpose("Verify explicit soft deletion after restart").ExecuteForListAsync(context); return new { graph=await Graph(context), states=orders.Select(o=>new {orderNumber=E.CustomerOrder(o).OrderNumber().Eval(),statusId=E.CustomerOrder(o).OrderStatusId().Eval(),version=E.CustomerOrder(o).Version().Eval()}).ToArray(), deleted=deleted.Select(i=>new {sku=E.OrderItem(i).SkuCode().Eval(),version=E.OrderItem(i).Version().Eval()}).ToArray() }; } static async Task OmitPreview(UserContext context) { var rows=await Q.CustomerOrders().WithOrderNumberIs("ORD-2026-1001") .SelectOrderItemListWith(Q.OrderItems().WithSkuCodeIs("SKU-NOTEBOOK").Limit(2)).Limit(2) .Comment("Load complete scalars with a filtered item preview").Purpose("Prove omitted items are not deletion commands").ExecuteForListAsync(context); Require(rows.Count==1 && rows[0].OrderItemList.Count==1,"Expected one preview line");var order=rows[0]; order.UpdateOrderNote("Edited through an item preview");await order.AuditAs("Edit Order note without replacing its item collection").SaveAsync(context); } static async Task RemoveLine(UserContext context,bool rollback) { var rows=await Q.CustomerOrders().WithOrderNumberIs("ORD-2026-1001") .SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAscending().OrderByIdAscending().Limit(101)).Limit(2) .Comment("Load complete Order for explicit line removal").Purpose("Recompute total from all retained items").ExecuteForListAsync(context); Require(rows.Count==1,"Expected one order");var order=rows[0]; Require(E.CustomerOrder(order).OrderStatusId().Eval()==1001,"Only DRAFT orders can be edited"); var items=order.OrderItemList;Require(items.Count>1 && items.Count<=100,"Invalid full item count"); var target=items.Single(i=>E.OrderItem(i).SkuCode().Eval()=="SKU-PEN");long total=0; checked {foreach(var item in items) { var e=E.OrderItem(item);long price=e.UnitPriceMinor().Eval() ?? throw new Exception("Missing price");long units=e.Quantity().Eval() ?? throw new Exception("Missing units"); Require(price>=0 && price<=100000 && units>=1 && units<=100 && e.LineTotalMinor().Eval()==price*units,"Invalid persisted item amount"); if(item!=target)total+=price*units; }}Require(total<=1000000000,"Total overflow"); if(rollback) { var winner=await Q.OrderItems().WithIdIs(E.OrderItem(target).Id().Eval() ?? throw new Exception("Missing ID")).Limit(2) .Comment("Load independent deletion competitor").Purpose("Test rollback when explicit deletion is stale").ExecuteForOneAsync(context) ?? throw new Exception("Missing winner"); winner.UpdateProductName("Pen (concurrent winner)");await winner.AuditAs("Advance Order item before stale deletion probe").SaveAsync(context); } target.MarkForDeletion();order.UpdateTotalMinor(total);Console.WriteLine("ORDER_REMOVAL_ATTEMPT"); await order.AuditAs("Remove Order line and recompute total atomically").SaveAsync(context); } static async Task Transition(UserContext context) { var target=Environment.GetEnvironmentVariable("ORDER_TARGET")!;long next=long.Parse(Environment.GetEnvironmentVariable("ORDER_NEXT_STATUS")!); var rows=await Q.CustomerOrders().WithOrderNumberIs(target).Limit(2) .Comment("Load full Order before state transition").Purpose("Apply the Order lifecycle policy with original version").ExecuteForListAsync(context); Require(rows.Count==1,"Expected one target");var order=rows[0];long current=E.CustomerOrder(order).OrderStatusId().Eval() ?? throw new Exception("Missing state"); var result=new Dictionary {{"target",target},{"from",current},{"to",next},{"observedVersion",E.CustomerOrder(order).Version().Eval()}}; if(!((current==1001 && (next==1002 || next==1003)) || (current==1002 && next==1003))) {result["outcome"]="rejected";result["reason"]="Transition not allowed";return result;} if(next==1002)order.UpdateOrderStatusToConfirmed();else order.UpdateOrderStatusToCancelled(); await order.AuditAs("Apply an allowed Order status transition").SaveAsync(context);result["outcome"]="committed";result["reason"]="";return result; } static object[] PageRows(IEnumerable orders,bool preview) => orders.Select(o=>{ var row=new Dictionary {{"id",E.CustomerOrder(o).Id().Eval()},{"orderNumber",E.CustomerOrder(o).OrderNumber().Eval()},{"buyer",E.CustomerOrder(o).BuyerReference().Eval()},{"totalMinor",E.CustomerOrder(o).TotalMinor().Eval()},{"version",E.CustomerOrder(o).Version().Eval()}}; if(preview)row["items"]=o.OrderItemList.Select(i=>new {id=E.OrderItem(i).Id().Eval(),sku=E.OrderItem(i).SkuCode().Eval(),lineTotalMinor=E.OrderItem(i).LineTotalMinor().Eval(),version=E.OrderItem(i).Version().Eval()}).ToArray(); return (object)row; }).ToArray(); static async Task BoundedPage(UserContext context) { int offset=int.Parse(Environment.GetEnvironmentVariable("ORDER_PAGE_OFFSET")!),limit=int.Parse(Environment.GetEnvironmentVariable("ORDER_PAGE_LIMIT")!);string buyer=Environment.GetEnvironmentVariable("ORDER_PAGE_BUYER")!; Console.WriteLine("ORDER_PAGES_BEGIN"); if(offset<0||limit<1||limit>3)return new {rejected=true,reason="Page bounds must be offset >= 0 and limit in [1, 3]"}; var page=await Q.CustomerOrders().WithBuyerReferenceIs(buyer).OrderByTotalMinorAscending().OrderByIdAscending() .SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAscending().OrderByIdAscending().Limit(1)).Offset(offset).Limit(limit).Count() .Comment("Read bounded Order pages").Purpose("Compare filtered totals and per-order item previews").ExecuteForListAsync(context); Require(page.TotalCount is not null,"Missing exact total");return new {offset,limit,buyer,rows=PageRows(page,true),total=page.TotalCount}; } static async Task ExportPages(UserContext context) { string mode=Environment.GetEnvironmentVariable("ORDER_EXPORT_MODE")!;bool complete=mode is "asc" or "desc"; Require(new[]{"asc","desc","miss","composite","predicate"}.Contains(mode),"Unknown export mode"); var pages=new List();int fallbackCount=0,seekCount=0;bool ended=false;Console.WriteLine("ORDER_PAGES_BEGIN"); for(int index=0;index<(complete?10:2);index++) { int offset=(index+(mode=="miss"?1:0))*3;string buyer=mode=="predicate"&&index==1?"BUYER-CONTROL":"BUYER-EXPORT"; var query=Q.CustomerOrders().WithBuyerReferenceIs(buyer); if(mode=="composite")query=query.OrderByTotalMinorAscending().OrderByIdAscending();else query=mode=="desc"?query.OrderByIdDescending():query.OrderByIdAscending(); Console.WriteLine("ORDER_EXPORT_PAGE "+index); var page=await query.Offset(offset).Limit(3).OptimizeForContinuousPageFetchWith("order-export-"+mode,300).Count() .Comment("Export Order pages").Purpose("Export complete bounded Order identities through one trusted context").ExecuteForListAsync(context); var plan=context.ContinuousPagePlan;Require(plan is not null&&page.TotalCount is not null,"Missing native page observation"); if(plan=="CURSOR_SEEK")seekCount++;else if(plan!.StartsWith("OFFSET_FALLBACK:"))fallbackCount++; pages.Add(new {offset,buyer,rows=PageRows(page,false),total=page.TotalCount,plan});if(complete&&page.Count==0){ended=true;break;} } Require(!complete||ended,"Export page budget exhausted");return new {mode,pages,fallbackCount,seekCount}; } static async Task Worker(UserContext context) { string Env(string key) => Environment.GetEnvironmentVariable(key) ?? throw new InvalidOperationException(key); var name=Env("ORDER_WORKER"); var target=Env("ORDER_TARGET"); var note=Env("ORDER_NOTE"); var rows=await Q.CustomerOrders().WithOrderNumberIs(target).Limit(2) .Comment("Load complete Order before write barrier").Purpose("Retain original version for concurrent note update").ExecuteForListAsync(context); Require(rows.Count==1,"Expected one worker order");var order=rows[0]; var result=new Dictionary {{"worker",name},{"target",target},{"note",note},{"pid",Environment.ProcessId}, {"observedVersion",E.CustomerOrder(order).Version().Eval()},{"observedNote",E.CustomerOrder(order).OrderNote().Eval()}}; var barrier=Env("ORDER_BARRIER");var temporary=Path.Combine(barrier,name+".tmp"); await File.WriteAllTextAsync(temporary,JsonSerializer.Serialize(result));File.Move(temporary,Path.Combine(barrier,name+".ready")); var timer=System.Diagnostics.Stopwatch.StartNew(); while(!File.Exists(Path.Combine(barrier,Env("ORDER_RELEASE")))) { Require(timer.Elapsed.TotalSeconds<45,"Worker barrier timeout");await Task.Delay(10); } order.UpdateOrderNote(note);var outcome="committed";var reason=""; try { await order.AuditAs("Revise Order note with optimistic version").SaveAsync(context); } catch(Exception error) { outcome="conflict";reason=error.ToString(); } result["outcome"]=outcome;result["conflictReason"]=reason; Console.WriteLine("ORDER_WORKER "+JsonSerializer.Serialize(result)); } static async Task RetainedPages(UserContext context) { string mode=Environment.GetEnvironmentVariable("ORDER_RETAINED_MODE")!;var store=new ObservedIds();context.WithIdSetStore(store); int[] offsets=mode switch {"jumps"=>[6,0,3,9,0],"empty" or "expiry"=>[0,3],"overflow"=>[3,0],"isolation"=>[0,0,3],"invalidate"=>[0,3,6],_=>throw new Exception("Unknown mode")}; var pages=new List();Console.WriteLine("ORDER_INSIGHTS_BEGIN"); for(int index=0;index OrderSummary(UserContext context) { string buyer=Environment.GetEnvironmentVariable("ORDER_SUMMARY_BUYER")!,currency=Environment.GetEnvironmentVariable("ORDER_SUMMARY_CURRENCY")!;int minimum=int.Parse(Environment.GetEnvironmentVariable("ORDER_SUMMARY_MINIMUM")!); double N(Value v)=>v.TryF64()??throw new Exception("Missing aggregate");Console.WriteLine("ORDER_INSIGHTS_BEGIN"); var groups=await Q.CustomerOrders().WithBuyerReferenceIs(buyer).WithCurrencyCodeIs(currency).WithTotalMinorGreaterThanOrEqualTo(minimum) .GroupByOrderStatus().CountAs("count").SumTotalMinorAs("totalMinor").Limit(4) .Comment("Summarize filtered Order amounts by status").Purpose("Compute same-currency Order summaries in the provider").ExecuteForRowsAsync(context); var summary=await Q.CustomerOrders().WithBuyerReferenceIs(buyer).WithCurrencyCodeIs(currency).WithTotalMinorGreaterThanOrEqualTo(minimum) .CountAs("count").SumTotalMinorAs("totalMinor").Limit(1) .Comment("Summarize the complete filtered Order set").Purpose("Compare exact counts and money independent of page size").ExecuteForRowsAsync(context); var sets=new List();object rows=Array.Empty();object? total=null; foreach(bool all in new[]{true,false}) { var page=await Q.CustomerOrders().WithBuyerReferenceIs(buyer).WithCurrencyCodeIs(currency).WithTotalMinorGreaterThanOrEqualTo(minimum) .FacetByOrderStatusAs("statuses",Q.OrderStatusesWithMinimalFields().SelectCode().CountCustomerOrdersAs("count").Limit(4),all) .SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAscending().OrderByIdAscending().Limit(1)).OrderByIdAscending().Limit(3).Count() .Comment("Read Order status buckets and bounded item previews").Purpose("Keep rows facets and counts on the same filtered set").ExecuteForListAsync(context); sets.Add(page.Facet("statuses")!.ToDictionary(r=>r["code"].TryText()!,r=>N(r["count"])));if(all){rows=PageRows(page,true);total=page.TotalCount;} } return new {buyer,currency,minimum,groups=groups.Rows.Select(r=>new {statusId=N(r["order_status"]),count=N(r["count"]),totalMinor=N(r["totalMinor"])}).ToArray(), summary=summary.Rows.Select(r=>new {count=N(r["count"]),totalMinor=r["totalMinor"].TryF64()}).ToArray(),allBuckets=sets[0],matchedBuckets=sets[1],rows,total}; } var phase = args.Single(); var module = GeneratedRuntimeModule.Module; var context = module.IntoContext(); await using var connection = new SqliteConnection("Data Source=" + Environment.GetEnvironmentVariable("ORDER_DATABASE")); await connection.OpenAsync(); context.WithDataService(new SqlDataServiceExecutor(new SqliteDialect(), new SqliteTransport(connection), new MetadataSchemaProvider(module.Metadata.GetEntity))); if(phase!="worker") await context.EnsureSchemaAsync(); switch (phase) { case "insights-retained": Report(phase,await RetainedPages(context));break; case "insights-summary": Report(phase,await OrderSummary(context));break; case "pages-bounded": Report(phase,await BoundedPage(context));break; case "pages-export": Report(phase,await ExportPages(context));break; case "complete-read": Report(phase,await CompleteRead(context));break; case "omission-probe": await OmitPreview(context);Report(phase,new {previewCount=1});break; case "remove-line": await RemoveLine(context,false);Report(phase,new {removed="SKU-PEN"});break; case "remove-conflict": { Exception? failure=null;try {await RemoveLine(context,true);}catch(Exception error){failure=error;} Require(failure is not null,"Stale deletion accepted");Report(phase,new {rejected=true,reason=failure!.ToString()});break; } case "transition": Report(phase,await Transition(context));break; case "guard-edit": { string reason="";try {await Edit(context,3,false);}catch(InvalidOperationException error){reason=error.Message;} Require(reason=="Only DRAFT orders can be edited","Expected state policy rejection");Report(phase,new {rejected=true,reason});break; } case "worker": await Worker(context); break; case "bootstrap": break; case "seed": using (var fixture = JsonDocument.Parse(File.ReadAllText(Environment.GetEnvironmentVariable("ORDER_FIXTURE")!))) { foreach (var input in fixture.RootElement.GetProperty("orders").EnumerateArray()) { var order = Q.CustomerOrders().Comment("Create fixture order").Purpose("Seed Order workflow").NewEntity(context); order.UpdateCommercePlatformId(1); switch(input.GetProperty("order_status").GetString()){case "DRAFT":order.UpdateOrderStatusToDraft();break;case "CONFIRMED":order.UpdateOrderStatusToConfirmed();break;case "CANCELLED":order.UpdateOrderStatusToCancelled();break;default:throw new Exception("Unknown fixture status");} order.UpdateOrderNumber(input.GetProperty("order_number").GetString()); order.UpdateBuyerReference(input.GetProperty("buyer_reference").GetString()); order.UpdateCurrencyCode(input.GetProperty("currency_code").GetString()); order.UpdateTotalMinor(input.GetProperty("total_minor").GetInt64()); order.UpdateOrderNote(input.GetProperty("order_note").GetString()); await order.AuditAs(Seed).SaveAsync(context); var id = E.CustomerOrder(order).Id().Eval() ?? throw new Exception("Missing saved ID"); foreach (var line in input.GetProperty("items").EnumerateArray()) { var item = Q.OrderItems().Comment("Create fixture item").Purpose("Seed Order workflow").NewEntity(context); item.UpdateCustomerOrderId(id); item.UpdateSkuCode(line.GetProperty("sku_code").GetString()); item.UpdateProductName(line.GetProperty("product_name").GetString()); item.UpdateQuantity(line.GetProperty("quantity").GetInt64()); item.UpdateUnitPriceMinor(line.GetProperty("unit_price_minor").GetInt64()); item.UpdateLineTotalMinor(line.GetProperty("line_total_minor").GetInt64()); await item.AuditAs(Seed).SaveAsync(context); } } } break; // scenario: draft-graph, restart-readback case "p1-read": case "draft-graph": case "restart-readback": Report(phase, await Graph(context)); break; // scenario: note-value, note-null, note-empty case "note-value": case "note-null": case "note-empty": { var number = phase == "note-null" ? "ORD-2026-1002" : phase == "note-empty" ? "ORD-2026-1003" : "ORD-2026-1001"; var order = await Q.CustomerOrdersWithMinimalFields().SelectOrderNote().WithOrderNumberIs(number).Limit(2) .Comment("Select nullable order note").Purpose("Verify loaded note and null-only default").ExecuteForOneAsync(context) ?? throw new Exception("Missing order"); Report(phase, new { value = E.CustomerOrder(order).OrderNote().Eval(), fallback = E.CustomerOrder(order).OrderNote().OrIfNull("No note") }); break; } // scenario: note-not-loaded case "note-not-loaded": { var order = await Q.CustomerOrdersWithMinimalFields().SelectOrderNumber().WithOrderNumberIs("ORD-2026-1001").Limit(2) .Comment("Omit order note from projection").Purpose("Expose missing-field errors").ExecuteForOneAsync(context) ?? throw new Exception("Missing order"); Report(phase, new { eval = Missing(() => E.CustomerOrder(order).OrderNote().Eval()), fallback = Missing(() => E.CustomerOrder(order).OrderNote().OrIfNull("No note")) }); break; } // scenario: invalid-quantity case "invalid-quantity": { var results = new List(); foreach (var quantity in new double[] { 0, -1, 1.5, 101 }) { try { await Edit(context, quantity, false); throw new Exception("Invalid quantity accepted"); } catch (ArgumentOutOfRangeException error) { results.Add(new { quantity, rejected = true, reason = error.Message }); } } Report(phase, results); break; } // scenario: draft-edit case "draft-edit": await Edit(context, 3, false); Report(phase, await Graph(context)); break; case "rollback-probe": { Exception? conflict = null; try { await Edit(context, 3, true); } catch (Exception error) { conflict = error; } Require(conflict is not null, "Stale child accepted"); Report(phase, new { rejected = true, reason = conflict!.ToString() }); break; } default: throw new ArgumentException("Unknown phase"); } Console.WriteLine("ORDER_OK phase=" + phase); sealed class ObservedIds : TeaQL.Runtime.IIdSetStore { readonly TeaQL.Runtime.InMemoryIdSetStore store=new();public List Events=new();public string? LastKey; public async ValueTask GetAsync(string key){LastKey=key;var value=await store.GetAsync(key);Events.Add(new {op="get",key,hit=value!=null});return value;} public async ValueTask PutAsync(TeaQL.Runtime.RetainedIdSet value){await store.PutAsync(value);Events.Add(new {op="put",key=value.QueryKey,ids=value.Ids});} public async ValueTask InvalidateAsync(string key){await store.InvalidateAsync(key);Events.Add(new {op="invalidate",key});} }