@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/src/cmp/perl/TestEntity_perl.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'
 
 import { perlStringLiteral } from './utility_perl'
@@ -40,11 +41,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 reporting a failed check without failing the test.
+function liveFlowGate(N: string, entity: any, needs: any, entidEnv: string,
+  strict: boolean): string {
+  const label = entity.name + ': basic flow'
+  let out = ''
+  if (0 < needs.keys.length) {
+    out += `  if ($setup->{live}) {
+    my @missing = grep { $setup->{synthetic_only} || !defined $setup->{idmap}{$_} } (${needs.keys.map((k: string) => `'${k}'`).join(', ')});
+    if (@missing) {
+      ${N}TestRunner::live_miss(LIVE_STRICT, '${label}', 'Live entity test blocked: needs ' . join(', ', @missing) . ' via ${entidEnv}');
+      last BASIC_FLOW;
+    }
+  }
+`
+  }
+  if (null != needs.blocked) {
+    out += `  if ($setup->{live}) {
+    ${N}TestRunner::live_miss(LIVE_STRICT, '${label}', 'Live entity test blocked: ${needs.blocked}');
+    last BASIC_FLOW;
+  }
+`
+  }
+  out += '  my $client = $setup->{client};\n'
+  if (null != needs.discover) {
+    const match = Object.entries(needs.discover)
+      .map(([k, v]: any) => `'${k}' => $setup->{idmap}{'${v}'}`).join(', ')
+    out += `  if ($setup->{live}) {
+    ${N}TestRunner::live_existing($setup, LIVE_STRICT, '${label}', '${entity.name}',
+      sub { $client->${entity.Name}(undef)->list({${match}}, undef) }) or last BASIC_FLOW;
+  }
+`
+  }
+  if (!strict) {
+    out += `  local $main::TODO = $setup->{live} ? 'live run, main.kit.test.live.strict is false' : undef;
+  eval {
+`
+  }
+  return out
+}
+
+
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
   const model: Model = ctx$.model
 
   const entity: ModelEntity = props.entity
+  const target = props.target
 
   const basicflow: ModelEntityFlow | undefined =
     getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
@@ -99,6 +144,12 @@ const TestEntity = cmp(function TestEntity(props: any) {
 
   const genCtx: GenCtx = { model, entity, flow: basicflow, N, PROJUPPER }
 
+  const strict = liveStrict(model, target.name)
+  const needs = liveFlowNeeds(entity, basicflow)
+  // The failure tests stream and list with no match, so they need a list a
+  // bare call can reach.
+  const hasList = opReachable((entity.op as any)?.list, [])
+
   File({ name: entity.name + '_entity.t' }, () => {
 
     Content(`#!perl
@@ -114,12 +165,15 @@ use Cwd ();
 use ${N}SDK;
 require(Cwd::abs_path("$FindBin::Bin/runner.pm"));
 
+${liveStrictNote(strict, '#')}
+use constant LIVE_STRICT => ${strict ? 1 : 0};
+
 {
   my $testsdk = ${N}SDK->test(undef, undef);
   my $ent = $testsdk->${entity.Name}(undef);
   ok(defined $ent, '${entity.name}: create instance');
 }
-
+${hasList ? failureTests(N, entity) : ''}${validateTest(N, entity)}
 BASIC_FLOW: {
   my $setup = ${entity.name}_basic_setup(undef);
   my $_live = $setup->{live} ? 1 : 0;
@@ -133,15 +187,7 @@ BASIC_FLOW: {
       last BASIC_FLOW;
     }
   }
-  # 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.
-  if ($setup->{synthetic_only}) {
-    note('live entity test uses synthetic IDs from fixture - set ${ENTIDVAR} JSON to run live');
-    pass('${entity.name}: basic flow skipped (synthetic IDs only)');
-    last BASIC_FLOW;
-  }
-  my $client = $setup->{client};
-  my %V;
+${liveFlowGate(N, entity, needs, ENTIDVAR, strict)}  my %V;
 
 `)
 
@@ -168,7 +214,9 @@ BASIC_FLOW: {
       }
     })
 
-    Content(`}
+    Content(`${strict ? '' : `    1;
+  } or ${N}TestRunner::live_observe($@, $setup, LIVE_STRICT, '${entity.name}: basic flow');
+`}}
 
 `)
 
@@ -201,10 +249,8 @@ BASIC_FLOW: {
     }
   );
 
-  # Detect ENTID env override before env_override consumes it. When live
-  # mode is on without a real override, the basic test runs against
-  # synthetic IDs from the fixture and 4xx's. Surface this so the test can
-  # skip.
+  # Whether *_ENTID supplied the idmap, read before env_override consumes
+  # it: without it, the ids a live flow binds are the fixture's synthetic ones.
   my $entid_env_raw = $ENV{'${ENTIDVAR}'};
   my $idmap_overridden = (defined $entid_env_raw && $entid_env_raw =~ /^\\s*\\{/) ? 1 : 0;
 
@@ -536,6 +582,121 @@ const GENERATE_OP: Record<string, OpGen> = {
 }
 
 
+// A failed operation raises from a stream as it does from the operation: a
+// transport failure, and a hook that rejects the call. A dying hook fires
+// PreUnexpected, and under throw false the call returns undef. The caller's
+// ctrl stays its own.
+function failureTests(N: string, entity: ModelEntity): string {
+  const Entity = entity.Name
+  const Hook = N + 'EntityTest' + Entity + 'FailHook'
+  return `
+{
+  package ${Hook};
+  our @ISA = ('${N}BaseFeature');
+
+  sub new {
+    my ($class) = @_;
+    my $self = ${N}BaseFeature::new($class);
+    $self->{name} = 'failhook';
+    $self->{unexpected} = 0;
+    return $self;
+  }
+
+  sub init { }
+  sub PreSpec { die "${entity.name} hook failed\\n" }
+  sub PreUnexpected { $_[0]->{unexpected}++; return }
+}
+
+{
+  my $offline = { net => { offline => 1 } };
+  my $died = !eval {
+    my $next = ${N}SDK->test($offline, undef)->${Entity}(undef)->stream('list', undef, undef);
+    1 while defined $next->();
+    1;
+  };
+  like($died ? "$@" : '', qr/offline/, '${entity.name}: a failed stream raises');
+
+  ok(eval {
+    my $next = ${N}SDK->test($offline, undef)->${Entity}(undef)
+      ->stream('list', undef, { ctrl => { throw => 0 } });
+    1 while defined $next->();
+    1;
+  }, '${entity.name}: under throw false a failed stream ends');
+
+  if (${N}Config::shared_config()->{feature}{rbac}) {
+    my $denied = ${N}SDK->test(undef, { feature => { rbac => { active => 1, deny => 1 } } });
+    my $denyerr = eval {
+      my $next = $denied->${Entity}(undef)->stream('list', undef, undef);
+      1 while defined $next->();
+      undef;
+    } // $@;
+    is(ref $denyerr ? $denyerr->{code} : undef, 'rbac_denied',
+      '${entity.name}: a denied stream raises');
+  }
+}
+
+{
+  my $explain = {};
+  my $ctrl = { explain => $explain };
+  my $next = ${N}SDK->test(undef, undef)->${Entity}(undef)
+    ->stream('list', undef, { ctrl => $ctrl });
+  1 while defined $next->();
+  is_deeply([sort keys %$ctrl], ['explain'], '${entity.name}: the stream leaves the caller ctrl');
+  ok($explain == $ctrl->{explain} && 0 < keys %$explain,
+    '${entity.name}: the caller explain record is filled');
+}
+
+{
+  my $hook = ${Hook}->new;
+  my $client = ${N}SDK->new({ feature => { test => { active => 1 } }, extend => [$hook] });
+
+  my $err = eval { $client->${Entity}(undef)->list(undef, undef); undef } // $@;
+  like("$err", qr/hook failed/, '${entity.name}: a dying hook fails the operation');
+  ok(0 < $hook->{unexpected}, '${entity.name}: PreUnexpected fired');
+
+  my $fired = $hook->{unexpected};
+  my $out = eval { $client->${Entity}(undef)->list(undef, { throw => 0 }) };
+  ok(!$@ && !defined $out, '${entity.name}: under throw false the call returns undef');
+  ok($fired < $hook->{unexpected}, '${entity.name}: PreUnexpected fired under throw false');
+}
+
+{
+  my $seed = { entity => { '${entity.name}' => { l1 => { id => 'l1' }, l2 => { id => 'l2' } } } };
+  my $items = ${N}SDK->test($seed, undef)->${Entity}(undef)->list(undef, undef);
+  # list resolves to one entity per record; data_get reads the record.
+  is(scalar(@$items), 2, '${entity.name}: list answers each seeded record');
+  my $entities = grep {
+    Scalar::Util::blessed($_) && $_->can('data_get') && Voxgig::Struct::ismap($_->data_get)
+  } @$items;
+  is($entities, 2, '${entity.name}: each listed item is an entity carrying its record');
+}
+`
+}
+
+
+// An invalid request fails with validate's own error, before it is sent.
+function validateTest(N: string, entity: ModelEntity): string {
+  const bad = invalidRequest(entity)
+  if (null == bad) {
+    return ''
+  }
+  const args = Object.entries(bad.args)
+    .map(([k, v]) => perlStringLiteral(k) + ' => ' +
+      ('string' === typeof v ? perlStringLiteral(v) : true === v ? '1' : String(v)))
+    .join(', ')
+  return `
+SKIP: {
+  skip('feature not present in this SDK: validate', 1)
+    unless ${N}Config::shared_config()->{feature}{validate};
+  my $client = ${N}SDK->test(undef, { feature => { validate => { active => 1 } } });
+  my $err = eval { $client->${entity.Name}(undef)->${bad.op}({ ${args} }, undef); undef } // $@;
+  is(ref $err ? $err->{code} : undef, 'validate_failed',
+    '${entity.name}: an invalid request fails with validate_failed');
+}
+`
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/perl/fragment/Entity.fragment.pm

@@ -127,6 +127,8 @@ sub match_get {
 
 # #UpdateOp
 
+# #PatchOp
+
 # #RemoveOp
 
 # Streaming operation. Runs `action` (an op name, e.g. 'list') through the
@@ -136,7 +138,7 @@ sub match_get {
 # result). When the streaming feature is active the result carries a `stream`
 # coderef and this yields from it (honouring chunkSize / chunkDelay); else it
 # falls back to yielding the materialised items so stream() always yields.
-# Yielded records are unwrapped to bare hashrefs (matching list()).
+# An entity is yielded as its record, the hashref its data_get returns.
 #
 # $callopts parameterises the call:
 #   - ctrl:   per-call pipeline control (threaded onto the op ctx);
@@ -149,8 +151,9 @@ sub stream {
   my $utility = $self->{_utility};
   $callopts = ProjectNameHelpers::to_map($callopts) || {};
   my $signal = ProjectNameHelpers::gp($callopts, 'signal');
-  my $ctrl = ProjectNameHelpers::to_map(
-    ProjectNameHelpers::gp($callopts, 'ctrl')) || {};
+  # A copy: the caller's ctrl gains no key, and explain stays its own record.
+  my $ctrl = { %{ ProjectNameHelpers::to_map(
+    ProjectNameHelpers::gp($callopts, 'ctrl')) || {} } };
   $ctrl->{stream} = $callopts;
 
   my $ctx = $utility->{make_context}->({
@@ -205,6 +208,17 @@ sub stream {
       if (my $operr = $@) {
         $src = sub { return undef };
         $ctx->{ctrl}{err} = $operr;
+
+        # What a hook dies with here must not escape the cleaning below.
+        my $fired = eval {
+          $utility->{feature_hook}->($ctx, 'PreUnexpected');
+          1;
+        };
+        if (!$fired) {
+          $operr = $@;
+          $ctx->{ctrl}{err} = $operr;
+        }
+
         my $e = $self->_unexpected($ctx, $operr);
         die $e if defined $e;
         return undef;

package/project/.sdk/src/cmp/perl/fragment/EntityCreateOp.fragment.pm

@@ -3,8 +3,8 @@
 # Create a new EntityName.
 #
 # reqdata: body data hashref (EntityNameCreateData shape). ctrl: optional
-# per-call control. Returns the created EntityName data (hashref); dies
-# with ProjectNameError on failure.
+# per-call control. Returns the created EntityName entity (data_get reads
+# its record); dies with ProjectNameError on failure.
 sub create {
   my ($self, $reqdata, $ctrl) = @_;
   my $utility = $self->{_utility};

package/project/.sdk/src/cmp/perl/fragment/EntityListOp.fragment.pm

@@ -5,8 +5,8 @@
 # reqmatch: match filter hashref (any subset of EntityName fields;
 # EntityNameListMatch shape); defaults to undef, treated as an empty match
 # that lists all. ctrl: optional per-call control.
-# Returns the matching EntityName items as an arrayref; dies with
-# ProjectNameError on failure.
+# Returns the matching EntityName items as an arrayref of entities, one per
+# record (data_get reads the record); dies with ProjectNameError on failure.
 sub list {
   my ($self, $reqmatch, $ctrl) = @_;
   my $utility = $self->{_utility};
@@ -26,17 +26,6 @@ sub list {
     return;
   });
 
-  # list yields the BARE arrayref of records - each an accessible hashref -
-  # so callers can index $item->{id} directly, matching py/lua/go/rb.
-  # make_result wraps each entry as an Entity instance for internal use;
-  # unwrap those back to their bare record hashrefs here (load/create/etc.
-  # are unaffected).
-  if (Voxgig::Struct::islist($records)) {
-    $records = [map {
-      (Scalar::Util::blessed($_) && $_->can('data_get')) ? $_->data_get : $_
-    } @$records];
-  }
-
   return $records;
 }
 

package/project/.sdk/src/cmp/perl/fragment/EntityLoadOp.fragment.pm

@@ -5,8 +5,8 @@
 # reqmatch: match criteria hashref (id/query fields; EntityNameLoadMatch
 # shape); optional - an entity with no id-like key loads with no match
 # (undef is treated as an empty match). ctrl: optional per-call control.
-# Returns the loaded EntityName data (hashref); dies with ProjectNameError
-# on failure.
+# Returns the loaded EntityName entity (data_get reads its record); dies
+# with ProjectNameError on failure.
 sub load {
   my ($self, $reqmatch, $ctrl) = @_;
   my $utility = $self->{_utility};

package/project/.sdk/src/cmp/perl/fragment/EntityPatchOp.fragment.pm

@@ -0,0 +1,32 @@
+# EJECT-START
+
+# Change part of an existing EntityName: only the fields given are sent.
+#
+# reqdata: body data hashref (EntityNamePatchData shape). ctrl: optional
+# per-call control. Returns the patched EntityName entity (data_get reads
+# its record); dies with ProjectNameError on failure.
+sub patch {
+  my ($self, $reqdata, $ctrl) = @_;
+  my $utility = $self->{_utility};
+  my $ctx = $utility->{make_context}->({
+    'opname' => 'patch',
+    'ctrl' => $ctrl,
+    'match' => $self->{_match},
+    'data' => $self->{_data},
+    'reqdata' => $reqdata,
+  }, $self->{_entctx});
+
+  return $self->_run_op($ctx, sub {
+    my $result = $ctx->{result};
+    if ($result) {
+      $self->{_match} = $result->{resmatch} if $result->{resmatch};
+      if ($result->{resdata}) {
+        $self->{_data} = ProjectNameHelpers::to_map(
+          Voxgig::Struct::clone($result->{resdata})) || {};
+      }
+    }
+    return;
+  });
+}
+
+# EJECT-END

package/project/.sdk/src/cmp/perl/fragment/EntityRemoveOp.fragment.pm

@@ -4,7 +4,7 @@
 #
 # reqmatch: match criteria hashref (id/query fields; EntityNameRemoveMatch
 # shape). ctrl: optional per-call control. Returns the removed EntityName
-# data (hashref); dies with ProjectNameError on failure.
+# entity, marked as deleted; dies with ProjectNameError on failure.
 sub remove {
   my ($self, $reqmatch, $ctrl) = @_;
   my $utility = $self->{_utility};

package/project/.sdk/src/cmp/perl/fragment/EntityUpdateOp.fragment.pm

@@ -3,8 +3,8 @@
 # Update an existing EntityName.
 #
 # reqdata: body data hashref (EntityNameUpdateData shape). ctrl: optional
-# per-call control. Returns the updated EntityName data (hashref); dies
-# with ProjectNameError on failure.
+# per-call control. Returns the updated EntityName entity (data_get reads
+# its record); dies with ProjectNameError on failure.
 sub update {
   my ($self, $reqdata, $ctrl) = @_;
   my $utility = $self->{_utility};

package/project/.sdk/src/cmp/perl/fragment/Main.fragment.pm

@@ -146,7 +146,14 @@ sub prepare {
   my $path = ProjectNameHelpers::gp($fetchargs, 'path');
   $path = '' unless defined $path && !ref $path;
   my $method_val = ProjectNameHelpers::gp($fetchargs, 'method');
-  $method_val = 'GET' unless defined $method_val && !ref $method_val;
+  $method_val = 'GET' unless defined $method_val && !ref $method_val && '' ne $method_val;
+  $method_val = uc $method_val;
+  my $allow_method = ProjectNameHelpers::gpath($opts, 'allow.method');
+  unless (ProjectNameUtilities::allowed($allow_method, $method_val)) {
+    $allow_method = '' unless defined $allow_method && !ref $allow_method;
+    die $ctx->make_error('spec_method_allow',
+      "Method \"$method_val\" not allowed by SDK option allow.method value: \"$allow_method\"");
+  }
   my $params = ProjectNameHelpers::to_map(
     ProjectNameHelpers::gp($fetchargs, 'params')) || {};
   my $query = ProjectNameHelpers::to_map(
@@ -201,8 +208,8 @@ sub direct {
 # Is this raw-access op permitted by the SDK's allow.op option?
 sub _op_allowed {
   my ($self, $op) = @_;
-  my $allow = ProjectNameHelpers::gpath($self->{options}, 'allow.op');
-  return (defined $allow && !ref $allow && index($allow, $op) >= 0) ? 1 : 0;
+  return ProjectNameUtilities::allowed(
+    ProjectNameHelpers::gpath($self->{options}, 'allow.op'), $op);
 }
 
 sub _op_denied {
@@ -266,20 +273,31 @@ sub _raw_request {
       || (defined $content_length && '0' eq "$content_length")) ? 1 : 0;
 
     my $json_data;
+    my $body_err;
     unless ($no_body) {
       my $jf = ProjectNameHelpers::gp($fetched, 'json');
       if (ref $jf eq 'CODE') {
         # Non-JSON body - leave data undef, keep status/headers.
         $json_data = eval { $jf->() };
       }
+      if (ProjectNameHelpers::gp($fetched, 'unreadable')) {
+        my $reason = ProjectNameHelpers::gp($fetched, 'statusText');
+        my $failed = ($status >= 200 && $status < 300) ? undef
+          : $ctx->make_error('request_status',
+            "request: $status: " . (defined $reason ? $reason : ''));
+        $body_err = ProjectNameUtilities::unreadable_body($ctx, $status, $headers,
+          ProjectNameHelpers::gp($fetched, 'body'), $fetchdef->{headers}, $failed);
+      }
     }
 
-    return {
-      'ok' => ($status >= 200 && $status < 300) ? 1 : 0,
+    my $out = {
+      'ok' => (!defined $body_err && $status >= 200 && $status < 300) ? 1 : 0,
       'status' => $status,
       'headers' => $headers,
       'data' => $json_data,
     };
+    $out->{err} = $utility->{clean}->($ctx, $body_err) if defined $body_err;
+    return $out;
   }
 
   return {

package/project/.sdk/src/cmp/perl/utility_perl.ts

@@ -6,6 +6,8 @@ import {
   walk,
 } from '@voxgig/struct'
 
+import { targetFeatures, canonScalarKey, requiredItems } from '@voxgig/sdkgen'
+
 
 function projectPath(suffix?: string): string {
   return Path.normalize(Path.join(__dirname, '../../..', suffix ?? ''))
@@ -58,8 +60,32 @@ function perlStringLiteral(val: string): string {
 }
 
 
+// The secrets plugin needs builtin::is_bool, from perl 5.36.
+function minPerl(model: any, target: any): string {
+  return null != (targetFeatures(model, target) as any).secrets ? '5.036' : '5.018'
+}
+
+
+function perlVersionLabel(version: string): string {
+  const [major, minor] = version.split('.')
+  return major + '.' + Number(minor.slice(0, 3))
+}
+
+function perlListArgs(entity: any): string {
+  const lit = (type: any): string =>
+    (({ NULL: 'undef', INTEGER: '1', NUMBER: '1', BOOLEAN: '1', ARRAY: '[]', OBJECT: '{}' }) as any)[canonScalarKey(type)] ?? "'example'"
+  const items = requiredItems(entity, 'list')
+  return 0 < items.length
+    ? `({ ${items.map((it: any) => `${perlStringLiteral(it.name)} => ${lit(it.type)}`).join(', ')} })`
+    : ''
+}
+
+
 export {
+  perlListArgs,
   perlStringLiteral,
   clean,
   projectPath,
+  minPerl,
+  perlVersionLabel,
 }

package/project/.sdk/src/cmp/php/EntityOperation_php.ts

@@ -1,7 +1,8 @@
 
 import {
   cmp, camelify,
-  Content, Fragment
+  Content, Fragment,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 
@@ -29,6 +30,7 @@ const EntityOperation = cmp(function Operation(props: any) {
       ProjectName: model.const.Name,
       EntityName: entity.Name,
       entityname: entity.name,
+      EntyClass: entityClassName(entity, entityCollection(model), true),
       '#Feature-Hook': ({ name, indent }: any) =>
         Content({ indent }, `
 ($u->feature_hook)($ctx, "${name}");

package/project/.sdk/src/cmp/php/EntityTypes_php.ts

@@ -6,7 +6,7 @@ import {
   File, Content, Folder,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames, phpSafeTypeName } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames, phpTypeName, entityCollection } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -76,7 +76,7 @@ declare(strict_types=1);
         const fields = (ent.fields ? each(ent.fields) : [])
           .filter((f: any) => f.a !== false && validName(f.n))
 
-        const TypeName = phpSafeTypeName(Name)
+        const TypeName = phpTypeName(ent, entityCollection(model))
 
         Content(`/** ${Name} entity data model. */
 class ${TypeName}
@@ -90,7 +90,7 @@ class ${TypeName}
 `)
 
         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
           }

package/project/.sdk/src/cmp/php/Entity_php.ts

@@ -21,9 +21,10 @@ const Entity = cmp(function Entity(props: any) {
 
   // Collision-free entity CLASS name (see entityClassName): normally
   // `<Name>Entity`, disambiguated when it would clash with another entity's
-  // data-type name. The snake-cased source-file name is unaffected.
+  // data-type name, compared as PHP does, ignoring case. The snake-cased
+  // source-file name is unaffected.
   const entityColl = entityCollection(model)
-  const cls = entityClassName(entity, entityColl)
+  const cls = entityClassName(entity, entityColl, true)
 
   const entrep = {
     ...stdrep,
@@ -41,7 +42,7 @@ const Entity = cmp(function Entity(props: any) {
       const opnames = Object.keys(entity.op || {})
 
       const opfrags =
-        (['load', 'list', 'create', 'update', 'remove']
+        (['load', 'list', 'create', 'update', 'patch', 'remove']
           .reduce((a: any, opname: string) =>
           (a['// #' + camelify(opname) + 'Op'] =
             !opnames.includes(opname) ? '' : ({ indent }: any) => {

package/project/.sdk/src/cmp/php/MainEntity_php.ts

@@ -17,7 +17,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
 
   // Collision-free entity CLASS name (entityClassName); the accessor METHOD name
   // (below) is unchanged so callers still write $client->${entity.Name}().
-  const cls = entityClassName(entity, entityCollection(model))
+  const cls = entityClassName(entity, entityCollection(model), true)
 
   const accessor = phpEntityAccessor(entity.Name)
 

package/project/.sdk/src/cmp/php/Main_php.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  inactiveFeatureExcludes,
   pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
@@ -48,7 +49,8 @@ const Main = cmp(async function Main(props: any) {
   // Copy tm/php files with replacements
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/^src(\/|$)/, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
+    exclude: [/^src(\/|$)/, TEST_CONTROL_EXCLUDE,
+      ...inactiveFeatureExcludes(props.ctx$, target), ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }

package/project/.sdk/src/cmp/php/Package_php.ts

@@ -44,7 +44,7 @@ const Package = cmp(async function Package(props: any) {
   "homepage": "${repoUrl}",
   "license": "MIT",
   "authors": [
-    { "name": "${author.name}"${'' === author.url ? '' : `, "homepage": "${author.url}"`} }
+    { "name": ${JSON.stringify(author.name)}${'' === author.url ? '' : `, "homepage": ${JSON.stringify(author.url)}`} }
   ],
   "support": {
     "issues": "${issuesUrl}",