@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/src/cmp/csharp/TestDirect_csharp.ts

@@ -15,6 +15,8 @@ import {
   serverVarEnv,
   serverVariables,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 import { formatCsValue } from './utility_csharp'
@@ -162,6 +164,9 @@ namespace ${Name}Sdk.Test;
 
 public class ${entity.Name}DirectTest
 {
+${liveStrictNote(liveStrict(model, target.name), '//', '    ')}
+    private const bool LIVE_STRICT = ${liveStrict(model, target.name)};
+
 `)
 
     // Generate list test first (load needs list results in live mode)
@@ -184,7 +189,8 @@ public class ${entity.Name}DirectTest
             {
                 if (StructUtils.GetProp(setup.Idmap, _liveKey) == null)
                 {
-                    return; // live test needs *_ENTID env var (synthetic IDs only)
+                    TestRunner.LiveMiss(LIVE_STRICT, "Live test blocked: needs " + _liveKey + " via ${entidEnvVar}");
+                    return;
                 }
             }
         }
@@ -246,16 +252,14 @@ ${listSkipBlock}        var client = setup.Client;
 
       Content(`        if (setup.Live)
         {
-            // Live mode is lenient: synthetic IDs frequently 4xx and the
-            // list-response shape varies wildly across public APIs. Bail
-            // rather than fail when the call doesn't return a usable list.
-            if (!Equals(result["ok"], true))
+            if (!TestRunner.LiveOk(result))
             {
+                TestRunner.LiveMiss(LIVE_STRICT, "Live list failed: " + TestRunner.LiveDescribe(result));
                 return;
             }
-            var status = Helpers.ToInt(result["status"]);
-            if (status < 200 || status >= 300)
+            if (TestRunner.LiveList(result["data"]) == null)
             {
+                TestRunner.LiveMiss(LIVE_STRICT, "Live list returned no list: " + TestRunner.LiveDescribe(result));
                 return;
             }
         }
@@ -299,17 +303,11 @@ ${listSkipBlock}        var client = setup.Client;
       // Identify ancestor params (not 'id') for live mode
       const ancestorParams = loadParams.filter((p: any) => p.n !== 'id')
 
+      const liveKey = (p: any) => p.n === 'id' ? entity.name + '01' : p.n.replace(/_id$/, '') + '01'
       let loadLiveIdKeys: string[] = []
       if (loadParams.length > 0 && !loadAllHaveExamples) {
-        if (hasList) {
-          loadLiveIdKeys = listParams.map((p: any) => {
-            return p.n === 'id'
-              ? entity.name + '01'
-              : p.n.replace(/_id$/, '') + '01'
-          })
-        } else {
-          loadLiveIdKeys = loadParams.map((p: any) => p.n + '01')
-        }
+        loadLiveIdKeys = [...new Set((hasList ?
+          [...listParams, ...loadParams.filter((p: any) => p.n !== 'id')] : loadParams).map(liveKey))]
       }
       const loadSkipBlock = loadLiveIdKeys.length > 0
         ? `        if (setup.Live)
@@ -318,7 +316,8 @@ ${listSkipBlock}        var client = setup.Client;
             {
                 if (StructUtils.GetProp(setup.Idmap, _liveKey) == null)
                 {
-                    return; // live test needs *_ENTID env var (synthetic IDs only)
+                    TestRunner.LiveMiss(LIVE_STRICT, "Live test blocked: needs " + _liveKey + " via ${entidEnvVar}");
+                    return;
                 }
             }
         }
@@ -375,23 +374,38 @@ ${loadSkipBlock}        var client = setup.Client;
                 ["method"] = "GET",
                 ["params"] = listParams,
             });
-            if (!Equals(listResult["ok"], true))
+            if (!TestRunner.LiveOk(listResult))
             {
-                return; // list call not ok (likely synthetic IDs)
+                TestRunner.LiveMiss(LIVE_STRICT, "Live list discovery failed: " + TestRunner.LiveDescribe(listResult));
+                return;
             }
-
-            // Get first entity ID from list
-            var listData = listResult["data"] as List<object?>;
-            if (listData == null || listData.Count == 0)
+            var listData = TestRunner.LiveList(listResult["data"]);
+            if (listData == null)
+            {
+                TestRunner.LiveMiss(LIVE_STRICT, "Live list discovery returned no list: " + TestRunner.LiveDescribe(listResult));
+                return;
+            }
+            if (listData.Count == 0)
             {
-                return; // no entities to load in live mode
+                TestRunner.LiveEmpty("The account has no ${entity.name} record to load");
+                return;
             }
             var firstEnt = Helpers.ToMapAny(listData[0]);
-            pathParams["id"] = firstEnt?["id"];
+            if (firstEnt == null || !firstEnt.TryGetValue("id", out var firstId) || firstId == null)
+            {
+                TestRunner.LiveMiss(LIVE_STRICT, "Live load blocked: discovery returned no usable identity");
+                return;
+            }
+            pathParams["id"] = firstId;
 `)
           for (const p of ancestorParams) {
             const key = p.n.replace(/_id$/, '') + '01'
             Content(`            pathParams["${p.n}"] = setup.Idmap["${key}"];
+`)
+          }
+        } else if (loadParams.length > 0) {
+          for (const p of loadParams) {
+            Content(`            pathParams["${p.n}"] = StructUtils.GetProp(setup.Idmap, "${liveKey(p)}");
 `)
           }
         }
@@ -427,18 +441,16 @@ ${loadSkipBlock}        var client = setup.Client;
       Content(`        });
         if (setup.Live)
         {
-            // Live mode is lenient: synthetic IDs frequently 4xx. Bail
-            // rather than fail when the load endpoint isn't reachable.
-            if (!Equals(result["ok"], true))
+            if (!TestRunner.LiveOk(result))
             {
+                TestRunner.LiveMiss(LIVE_STRICT, "Live load failed: " + TestRunner.LiveDescribe(result));
                 return;
             }
-            var status = Helpers.ToInt(result["status"]);
-            if (status < 200 || status >= 300)
+            if (result["data"] == null)
             {
+                TestRunner.LiveMiss(LIVE_STRICT, "Live load returned no data: " + TestRunner.LiveDescribe(result));
                 return;
             }
-            Assert.NotNull(result["data"]);
         }
         else
         {

package/project/.sdk/src/cmp/csharp/TestEntity_csharp.ts

@@ -1,4 +1,4 @@
-import { flowSteps } from '@voxgig/sdkgen'
+import { flowSteps, opReachable, invalidRequest } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -20,7 +20,8 @@ import {
   getMatchEntries,
   isAuthActive, envName, envToken,
   serverVarEnv,
-  serverVariables
+  serverVariables,
+  liveFlowNeeds, liveStrict, liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
@@ -43,6 +44,55 @@ type GenCtx = {
 type OpGen = (ctx: GenCtx, step: ModelEntityFlowStep, index: number) => void
 
 
+// The live prologue of a flow built from offline fixtures: blocked without
+// the ids it binds, a create-less load reading the first listed record, and
+// a lenient run observing its checks rather than failing on them.
+function liveFlowGate(entity: any, needs: any, entidEnv: string, strict: boolean,
+  hasSteps: boolean): string {
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `        if (setup.Live)
+        {
+            foreach (var liveKey in new[] { ${needs.keys.map((k: string) => JSON.stringify(k)).join(', ')} })
+            {
+                if (setup.SyntheticOnly || StructUtils.GetProp(setup.Idmap, liveKey) == null)
+                {
+                    TestRunner.LiveMiss(LIVE_STRICT, "Live entity test blocked: needs " + liveKey + " via ${entidEnv}");
+                    return;
+                }
+            }
+        }
+`
+  }
+  if (null != needs.blocked) {
+    out += `        if (setup.Live)
+        {
+            TestRunner.LiveMiss(LIVE_STRICT, "Live entity test blocked: " + ${JSON.stringify(needs.blocked)});
+            return;
+        }
+`
+  }
+  if (!hasSteps) {
+    return out
+  }
+  out += '        var client = setup.Client;\n'
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => ` [${JSON.stringify(k)}] = setup.Idmap[${JSON.stringify(v)}],`).join('')
+    out += `        if (setup.Live && !TestRunner.LiveExisting(setup.Data, LIVE_STRICT, ${JSON.stringify(entity.name)},
+            () => client.${entity.Name}().List(new Dictionary<string, object?> {${match} }, null)))
+        {
+            return;
+        }
+`
+  }
+  if (!strict) {
+    out += '        try\n        {\n'
+  }
+  return out + '\n'
+}
+
+
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model
@@ -95,6 +145,10 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, flow: basicflow, PROJUPPER }
 
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+  const entidEnvVar = `${PROJUPPER}_TEST_${ENTUPPER}_ENTID`
+
   const opNames = Array.from(new Set(
     (allSteps as any[]).map((s: any) => s.o).filter(Boolean)))
   const opsList = opNames.map(o => `"${o}"`).join(', ')
@@ -124,6 +178,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
 using System.Text.Json;
 
+using ${Name}Sdk.Feature;
 using Voxgig.Struct;
 using Xunit;
 
@@ -131,6 +186,9 @@ namespace ${Name}Sdk.Test;
 
 public class ${entity.Name}EntityTest
 {
+${liveStrictNote(strict, '//', '    ')}
+    private const bool LIVE_STRICT = ${strict};
+
     [Fact]
     public void Instance()
     {
@@ -143,14 +201,7 @@ public class ${entity.Name}EntityTest
     public void Basic()
     {
         var setup = ${entity.Name}BasicSetup(null);
-${skipBlock}        // The basic flow consumes synthetic IDs from the fixture. In live
-        // mode without an *_ENTID env override, those IDs hit the live API
-        // and 4xx; set ${PROJUPPER}_TEST_${ENTUPPER}_ENTID JSON to run live.
-        if (setup.SyntheticOnly)
-        {
-            return;
-        }
-${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
+${skipBlock}${liveFlowGate(entity, needs, entidEnvVar, strict, allSteps.length > 0)}`)
 
     // Check if the flow has a create step; if not, bootstrap entity data
     const flowHasCreate = allSteps.some((s: any) => s.o === 'create')
@@ -176,11 +227,18 @@ ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
       }
     })
 
-    Content(`    }
+    Content(`${strict || 0 === allSteps.length ? '' : `        }
+        catch (Exception liveErr)
+        {
+            TestRunner.LiveObserve(liveErr, setup.Live, LIVE_STRICT);
+        }
+`}    }
 
 `)
 
-    const flowHasList = allSteps.some((s: any) => s.o === 'list')
+    // The stream test lists with no match, so a bare call must reach a route.
+    const flowHasList = allSteps.some((s: any) => s.o === 'list') &&
+      opReachable((entity.op as any)?.list, [])
     if (flowHasList) {
       Content(`    [Fact]
     public async Task Stream()
@@ -227,6 +285,8 @@ ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
 `)
     }
 
+    Content(failureTests(Name, entity, opReachable((entity.op as any)?.list, [])))
+
     // Generate setup function
     Content(`    private static EntityTestSetup ${entity.Name}BasicSetup(
         Dictionary<string, object?>? extra)
@@ -267,9 +327,8 @@ ${allSteps.length > 0 ? '        var client = setup.Client;\n\n' : ''}`)
                 },
             });
 
-        // Detect ENTID env override before EnvOverride consumes it. When
-        // live mode is on without a real override, the basic test runs
-        // against synthetic IDs from the fixture and 4xx's.
+        // Whether *_ENTID supplied the idmap, read before EnvOverride consumes
+        // it: without it, the ids a live flow binds are the fixture's synthetic ones.
         var entidEnvRaw = Environment.GetEnvironmentVariable(
             "${PROJUPPER}_TEST_${ENTUPPER}_ENTID") ?? "";
         var idmapOverridden = entidEnvRaw != "" &&
@@ -641,6 +700,119 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A failed operation throws from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A throwing hook fires
+// PreUnexpected, under throw false too. The caller's ctrl stays its own. An
+// invalid request fails with validate's own error, before it is sent.
+function failureTests(Name: string, entity: ModelEntity, hasList: boolean): string {
+  const Entity = entity.Name
+  const map = (body: string) => 'new Dictionary<string, object?> { ' + body + ' }'
+  let out = ''
+
+  if (hasList) {
+    out += `    private sealed class FailHook : BaseFeature
+    {
+        public int Unexpected;
+
+        public FailHook()
+        {
+            Name = "failhook";
+            Version = "0.0.1";
+            Active = true;
+        }
+
+        public override void PreSpec(Context ctx) =>
+            throw new Exception("${entity.name} hook failed");
+
+        public override void PreUnexpected(Context ctx) => Unexpected++;
+    }
+
+    [Fact]
+    public async Task StreamError()
+    {
+        var offline = ${map('["net"] = ' + map('["offline"] = true'))};
+        var err = await Assert.ThrowsAnyAsync<Exception>(async () =>
+        {
+            await foreach (var _ in ${Name}SDK.TestSDK(offline, null).${Entity}().Stream("list", null, null)) { }
+        });
+        Assert.Contains("offline", err.Message);
+
+        await foreach (var _ in ${Name}SDK.TestSDK(offline, null).${Entity}().Stream("list", null,
+            ${map('["ctrl"] = ' + map('["throw"] = false'))})) { }
+
+        if (Fh.HasFeature("rbac"))
+        {
+            var denied = ${Name}SDK.TestSDK(null,
+                ${map('["feature"] = ' + map('["rbac"] = ' + map('["active"] = true, ["deny"] = true')))});
+            var denyerr = await Assert.ThrowsAnyAsync<${Name}Error>(async () =>
+            {
+                await foreach (var _ in denied.${Entity}().Stream("list", null, null)) { }
+            });
+            Assert.Equal("rbac_denied", denyerr.Code);
+        }
+    }
+
+    [Fact]
+    public async Task StreamCtrl()
+    {
+        var explain = new Dictionary<string, object?>();
+        var ctrl = new Dictionary<string, object?> { ["explain"] = explain };
+        await foreach (var _ in ${Name}SDK.TestSDK(null, null).${Entity}().Stream("list", null,
+            ${map('["ctrl"] = ctrl')})) { }
+        Assert.Equal(new[] { "explain" }, ctrl.Keys.ToArray());
+        Assert.Same(explain, ctrl["explain"]);
+        Assert.NotEmpty(explain);
+    }
+
+    [Fact]
+    public void Unexpected()
+    {
+        var hook = new FailHook();
+        var client = new ${Name}SDK(new Dictionary<string, object?>
+        {
+            ["feature"] = ${map('["test"] = ' + map('["active"] = true'))},
+            ["extend"] = new List<object?> { hook },
+        });
+
+        var err = Assert.ThrowsAny<Exception>(() => client.${Entity}().List(null, null));
+        Assert.Contains("hook failed", err.Message);
+        Assert.True(hook.Unexpected > 0);
+
+        var fired = hook.Unexpected;
+        client.${Entity}().List(null, ${map('["throw"] = false')});
+        Assert.True(hook.Unexpected > fired);
+    }
+
+`
+  }
+
+  const bad = invalidRequest(entity)
+  if (null != bad) {
+    const args = Object.entries(bad.args)
+      .map(([k, v]) => '[' + JSON.stringify(k) + '] = ' + JSON.stringify(v)).join(', ')
+    const Op = bad.op[0].toUpperCase() + bad.op.slice(1)
+    out += `    [Fact]
+    public void Validate()
+    {
+        if (!Fh.HasFeature("validate"))
+        {
+            Console.WriteLine("skip: feature not present in this SDK: validate");
+            return;
+        }
+        var client = ${Name}SDK.TestSDK(null,
+            ${map('["feature"] = ' + map('["validate"] = ' + map('["active"] = true')))});
+        var err = Assert.ThrowsAny<${Name}Error>(() => client.${Entity}().${Op}(
+            ${map(args)}, null));
+        Assert.Equal("validate_failed", err.Code);
+    }
+
+`
+  }
+
+  return out
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/csharp/fragment/Entity.fragment.cs

@@ -24,5 +24,7 @@ public class EntyClass : ProjectNameEntityBase
 
     // #UpdateOp
 
+    // #PatchOp
+
     // #RemoveOp
 }

package/project/.sdk/src/cmp/csharp/fragment/EntityBase.fragment.cs

@@ -114,6 +114,10 @@ public abstract class ProjectNameEntityBase : IEntity
         Dictionary<string, object?>? ctrl = null)
         => throw Helpers.UnsupportedOp("update", name);
 
+    public virtual object? Patch(Dictionary<string, object?>? reqdata,
+        Dictionary<string, object?>? ctrl = null)
+        => throw Helpers.UnsupportedOp("patch", name);
+
     public virtual object? Remove(Dictionary<string, object?>? reqmatch,
         Dictionary<string, object?>? ctrl = null)
         => throw Helpers.UnsupportedOp("remove", name);
@@ -258,13 +262,18 @@ public abstract class ProjectNameEntityBase : IEntity
     {
         callopts ??= new Dictionary<string, object?>();
 
+        // Read between yields only: the request itself is not cancelled,
+        // where ts and js cancel it in flight.
         var signal =
             StructUtils.GetProp(callopts, "signal") is CancellationToken sigTok
                 ? sigTok
                 : CancellationToken.None;
 
-        var ctrl = Helpers.ToMapAny(StructUtils.GetProp(callopts, "ctrl"))
-            ?? new Dictionary<string, object?>();
+        // A copy: the caller's ctrl gains no key, and explain stays its own record.
+        var callerCtrl = Helpers.ToMapAny(StructUtils.GetProp(callopts, "ctrl"));
+        var ctrl = callerCtrl == null
+            ? new Dictionary<string, object?>()
+            : new Dictionary<string, object?>(callerCtrl);
         ctrl["stream"] = callopts;
 
         var ctxmap = new Dictionary<string, object?>

package/project/.sdk/src/cmp/csharp/fragment/EntityPatchOp.fragment.cs

@@ -0,0 +1,41 @@
+// Patch operation fragment (spliced into the entity class by
+// EntityOperation_csharp; only the EJECT region is emitted).
+
+namespace ProjectNameSdk.Entity;
+
+public class EntyClassPatchOpFragment : EntyClass
+{
+    public EntyClassPatchOpFragment(ProjectNameSDK client) : base(client) { }
+
+// EJECT-START
+public override object? Patch(Dictionary<string, object?>? reqdata,
+    Dictionary<string, object?>? ctrl = null)
+{
+    var ctx = utility.MakeContext(new Dictionary<string, object?>
+    {
+        ["opname"] = "patch",
+        ["ctrl"] = ctrl,
+        ["match"] = match,
+        ["data"] = data,
+        ["reqdata"] = reqdata,
+    }, entctx);
+
+    return RunOp(ctx, () =>
+    {
+        if (ctx.Result != null)
+        {
+            if (ctx.Result.Resmatch != null)
+            {
+                match = ctx.Result.Resmatch;
+            }
+            if (ctx.Result.Resdata != null)
+            {
+                data = Helpers.ToMapAny(
+                    Voxgig.Struct.StructUtils.Clone(ctx.Result.Resdata))
+                    ?? new Dictionary<string, object?>();
+            }
+        }
+    });
+}
+// EJECT-END
+}

package/project/.sdk/src/cmp/csharp/fragment/Main.fragment.cs

@@ -133,6 +133,15 @@ public class ProjectNameSDK
         {
             method = "GET";
         }
+        method = method.ToUpperInvariant();
+
+        var allowMethod = global::Voxgig.Struct.StructUtils.GetPath(options, global::Voxgig.Struct.StructUtils.Jt("allow", "method"));
+        if (!global::ProjectNameSdk.Helpers.Allowed(allowMethod, method))
+        {
+            throw ctx.MakeError("spec_method_allow",
+                "Method \"" + method + "\" not allowed by SDK option allow.method value: \"" +
+                (allowMethod as string ?? "") + "\"");
+        }
 
         var pathParams = global::ProjectNameSdk.Helpers.ToMapAny(global::Voxgig.Struct.StructUtils.GetProp(fetchargs, "params"))
             ?? new Dictionary<string, object?>();
@@ -189,8 +198,8 @@ public class ProjectNameSDK
     // Is this raw-access op permitted by the SDK's allow.op option?
     private bool OpAllowed(string op)
     {
-        return global::Voxgig.Struct.StructUtils.GetPath(_options, global::Voxgig.Struct.StructUtils.Jt("allow", "op"))
-            is string allow && allow.Contains(op);
+        return global::ProjectNameSdk.Helpers.Allowed(
+            global::Voxgig.Struct.StructUtils.GetPath(_options, global::Voxgig.Struct.StructUtils.Jt("allow", "op")), op);
     }
 
     private Dictionary<string, object?> OpDenied(string op)
@@ -286,13 +295,28 @@ public class ProjectNameSDK
                 jsonData = jf();
             }
 
-            return new Dictionary<string, object?>
+            Exception? bodyErr = null;
+            if (!noBody && global::Voxgig.Struct.StructUtils.GetProp(fm, "unreadable") is true)
             {
-                ["ok"] = status >= 200 && status < 300,
+                var failed = status >= 200 && status < 300 ? null : ctx.MakeError("request_status",
+                    "request: " + status + ": " + global::Voxgig.Struct.StructUtils.GetProp(fm, "statusText"));
+                bodyErr = global::ProjectNameSdk.Response.UnreadableBody(ctx, status, headers,
+                    global::Voxgig.Struct.StructUtils.GetProp(fm, "body"),
+                    fetchdef.TryGetValue("headers", out var sent) ? sent : null, failed);
+            }
+
+            var direct = new Dictionary<string, object?>
+            {
+                ["ok"] = bodyErr == null && status >= 200 && status < 300,
                 ["status"] = status,
                 ["headers"] = headers,
                 ["data"] = jsonData,
             };
+            if (bodyErr != null)
+            {
+                direct["err"] = CleanErr(ctx, bodyErr);
+            }
+            return direct;
         }
 
         return new Dictionary<string, object?>

package/project/.sdk/src/cmp/csharp/utility_csharp.ts

@@ -6,6 +6,8 @@ import {
   camelify,
   each,
   safeVarName,
+  canonScalarKey,
+  requiredItems,
 } from '@voxgig/sdkgen'
 
 import {
@@ -98,6 +100,11 @@ function formatCsString(val: string): string {
 }
 
 
+function xmlText(s: string): string {
+  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+
 // The whole config JSON as a C# string literal.
 //
 // JSON.stringify output is otherwise a valid C# literal - every escape it
@@ -197,8 +204,19 @@ function clean(o: any, dropDefaults?: boolean): any {
   return prune(o, true === dropDefaults)
 }
 
+// A list's required route and query parameters, as the match it is called with.
+function csListMatch(entity: any): string {
+  const lit = (type: any): string =>
+    (({ NULL: 'null', INTEGER: '1L', NUMBER: '1.0', BOOLEAN: 'true', ARRAY: 'new List<object?>()', OBJECT: 'new Dictionary<string, object?>()' }) as any)[canonScalarKey(type)] ?? '"example"'
+  const items = requiredItems(entity, 'list')
+  return 0 < items.length
+    ? `new Dictionary<string, object?> {${items.map((it: any) => ` [${csStringLiteral(it.name)}] = ${lit(it.type)}`).join(',')} }`
+    : 'null'
+}
+
 
 export {
+  csListMatch,
   clean,
   csPascalName,
   csStringLiteral,
@@ -207,4 +225,5 @@ export {
   formatCsValue,
   formatCsString,
   projectPath,
+  xmlText,
 }

package/project/.sdk/src/cmp/elixir/EntityOperation_elixir.ts

@@ -2,6 +2,7 @@
 import {
   cmp, camelify,
   Fragment,
+  elixirTypeName, entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -14,6 +15,10 @@ const EntityOperation = cmp(function Operation(props: any) {
     eject: ['# EJECT-START', '# EJECT-END'],
     replace: {
       ...entrep,
+      // Longer keys match first, so the bare type keeps its safe name while
+      // the op types beside it take the plain one.
+      'ProjectName.Types.entityname/0': model.const.Name + '.Types.' +
+        elixirTypeName(entity, entityCollection(model)) + '/0',
       ProjectName: model.const.Name,
       EntityName: entity.Name,
       entityname: entity.name,

package/project/.sdk/src/cmp/elixir/EntityTypes_elixir.ts

@@ -6,7 +6,7 @@ import {
   File, Folder, Content,
 } from '@voxgig/sdkgen'
 
-import { opRequestShape, OP_SUFFIX, warnEntityTypeCollisions, deriveEntityNames } from '@voxgig/sdkgen'
+import { opRequestShape, OP_SUFFIX, warnEntityTypeCollisions, deriveEntityNames, elixirTypeName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -92,13 +92,13 @@ defmodule ${Name}.Types do
           .filter((f: any) => f.a !== false)
 
         emitType(
-          ename,
+          elixirTypeName(ent, entityCollection(model)),
           `${EName} entity data model.`,
           fields.map((f: any) => ({ name: f.n, type: f.t, optional: false === f.r })),
         )
 
         const ops = ent.op || {}
-        ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+        ;['load', 'list', 'create', 'update', 'patch', 'remove'].forEach((opname: string) => {
           if (null == ops[opname]) {
             return
           }