@voxgig/sdkgen 4.34.0 → 4.34.2

package/src/helpers/stdrep.ts

@@ -1,5 +1,5 @@
 
-import { envName, packageVersion } from './packageMeta'
+import { envName, packageVersion, publisherInfo } from './packageMeta'
 
 
 function ensureStdrep(ctx$: any): any {
@@ -9,6 +9,10 @@ function ensureStdrep(ctx$: any): any {
     stdrep.PROJECTENV = envName(ctx$.model)
   }
 
+  if (null == stdrep.PROJECTPUBLISHER) {
+    stdrep.PROJECTPUBLISHER = publisherInfo(ctx$.model).name
+  }
+
   return stdrep
 }
 

package/src/helpers/testPolicy.ts

@@ -1,5 +1,8 @@
 import { KIT } from '../types'
 
+import { flowSteps } from './buildIdNames'
+
+
 function liveStrict(model: any, target?: string): boolean {
   const perTarget = null == target ? undefined :
     model?.main?.[KIT]?.target?.[target]?.test?.live?.strict
@@ -7,4 +10,68 @@ function liveStrict(model: any, target?: string): boolean {
   return false !== configured
 }
 
-export { liveStrict }
+
+// The comment a generated live test carries, in the target's own comment
+// syntax, so every target states the setting and its effect alike.
+function liveStrictNote(strict: boolean, prefix: string, indent = ''): string {
+  return [
+    `main.kit.test.live.strict is ${strict} (the default is true): a live`,
+    'request that fails, or a live test missing an input it needs,',
+    strict ? 'fails the test.' : 'skips the test with the reason.',
+    'An account with no record for a test to read skips it either way.',
+  ].map((line) => indent + prefix + ' ' + line).join('\n')
+}
+
+
+type LiveFlowNeeds = {
+  // idmap keys the steps bind, which only the *_ENTID variable supplies live
+  keys: string[]
+  // match of the list that finds the existing record a create-less load reads
+  discover?: Record<string, string>
+  // why the flow cannot run against a live API at all
+  blocked?: string
+}
+
+
+// What an entity flow generated from the offline fixtures needs before it
+// can run live. A flow that creates its record needs nothing of the
+// fixture's; one that only reads takes the first record its list finds.
+function liveFlowNeeds(entity: any, flow: any): LiveFlowNeeds {
+  const steps: any[] = flowSteps(flow)
+  const hasCreate = steps.some((step) => 'create' === step.o)
+  const bound = (map: any) => Object.entries(map || {})
+    .filter(([k, v]: any) => !k.endsWith('$') && 'string' === typeof v && '' !== v)
+    .map(([, v]) => v as string)
+
+  const keys = new Set<string>()
+  for (const step of steps) {
+    if ('create' === step.o || 'list' === step.o) bound(step.m).forEach((k) => keys.add(k))
+    if ('update' === step.o) bound(step.d).forEach((k) => keys.add(k))
+  }
+
+  const needs: LiveFlowNeeds = { keys: [...keys] }
+  if (hasCreate || null == entity?.id) {
+    return needs
+  }
+
+  if (steps.some((step) => 'update' === step.o)) {
+    needs.blocked = 'the flow updates a ' + entity.name + ' record it did not create'
+  }
+  else if (steps.some((step) => 'load' === step.o)) {
+    const list = steps.find((step) => 'list' === step.o)
+    if (null == list) {
+      needs.blocked = 'the flow loads a ' + entity.name + ' record it has no list to find'
+    }
+    else {
+      needs.discover = Object.fromEntries(Object.entries(list.m || {})
+        .filter(([k, v]: any) => !k.endsWith('$') && 'string' === typeof v && '' !== v)) as any
+    }
+  }
+
+  return needs
+}
+
+
+export type { LiveFlowNeeds }
+
+export { liveStrict, liveStrictNote, liveFlowNeeds }

package/src/helpers/text.ts

@@ -0,0 +1,33 @@
+
+import { KIT } from '@voxgig/apidef'
+
+
+// The prose a project writes under `main.kit.text`, over `main.kit.info`,
+// where the spec and older projects put it. An empty slot falls through.
+function modelText(model: any): any {
+  const info = model?.main?.[KIT]?.info || {}
+  const text = model?.main?.[KIT]?.text || {}
+
+  const out: any = { ...info, entity_desc: { ...(info.entity_desc || {}) } }
+  for (const [slot, value] of Object.entries(text)) {
+    if ('entity_desc' === slot) {
+      for (const [entity, desc] of Object.entries(value || {})) {
+        if (given(desc)) out.entity_desc[entity] = desc
+      }
+    }
+    else if (given(value)) {
+      out[slot] = value
+    }
+  }
+  return out
+}
+
+
+function given(value: any): boolean {
+  return null != value && '' !== value
+}
+
+
+export {
+  modelText,
+}

package/src/sdkgen.ts

@@ -17,7 +17,7 @@ import type {
   ActionResult,
 } from './types'
 
-import { SdkGenError, requirePath, isAuthActive, resolveAuthPrefix, resolveAuthIn, resolveAuthName, isAuthSuppressed, isHttpBasicAuth,
+import { SdkGenError, requirePath, isAuthActive, resolveAuthPrefix, resolveAuthIn, resolveAuthName, credentialPlacement, isAuthSuppressed, isHttpBasicAuth,
   CONFIG_DATA_THRESHOLD, CONFIG_REPR_VALUES, isConfigData, configRepr,
   configReprSetting, configDefinition, clean, rawStringLiteral } from './utility'
 
@@ -57,22 +57,32 @@ import { registerComponent } from './cmp/Registered'
 
 import { resolvedFor, liveHint, pointFacts, boundedFacts, hasLiveScenarios } from './helpers/resolved'
 import { definitionPlan } from './helpers/definitionPlan'
+import { RAW_BODY, bodyNote, opRawBody, opRequestBody } from './helpers/media'
 import type { RegisterOptions } from './cmp/Registered'
 
 import { buildIdNames, entityRelationName, flowSteps } from './helpers/buildIdNames'
 import { getMatchEntries } from './helpers/getMatchEntries'
 import { collectDeps } from './helpers/collectDeps'
 import { guardModelNames } from './helpers/modelNames'
+import { guardFlowSteps } from './helpers/flowGuard'
+import { claimedFiles, pruneGenerated } from './helpers/generated'
+import { cmp as labelledCmp } from './helpers/component'
 import type { DepEntry } from './helpers/collectDeps'
 import { canonToType, canonToDtype, canonKey, canonScalarKey } from './helpers/canonType'
 import { canonToSpec, entityDataSpec, entityOpSpec, entitySpecs } from './helpers/canonSpec'
 import { optionSpec, featureOptionSpec, entitySpecMap } from './helpers/optspec'
-import { OP_SUFFIX, opTypeName, opParams, ownPoint, opActions, entityActions, entityPath, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, deriveEntityNames, entityCollection } from './helpers/opShape'
-import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, isRbSdkConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, isPhpReservedType, isPhpSdkClass, phpSafeTypeName, isTsReservedType, isTsSdkType, tsSafeTypeName, jsProp, jsOptProp, jsKey, luaKey, prefixLeadingDigit } from './helpers/naming'
+import { OP_SUFFIX, opTypeName, opParams, opReachable, opNeedsAction, ownPoint, opActions, entityActions, entityPath, opRequestShape, entityIdField, entityDataIdField, entityOps, invalidRequest, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, ungeneratedOps, warnUngeneratedOps, deriveEntityNames, entityCollection } from './helpers/opShape'
+import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, isRbSdkConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, isPhpReservedType, isPhpSdkClass, phpSafeTypeName, isTsReservedType, isTsSdkType, tsSafeTypeName, isElixirReservedType, elixirSafeTypeName, elixirTypeNames, elixirTypeName, elixirAccessorNames, elixirAccessor, tsTypeName, rbTypeName, phpTypeName, swiftTypeName, jsProp, jsOptProp, jsKey, jsQuote, luaKey, prefixLeadingDigit } from './helpers/naming'
 import { serverVariables, hasServerVariables, serverVarEnv } from './helpers/serverVars'
-import { primaryOpCall, idLiteral, matchArg, dataArg, litFor } from './helpers/opExample'
-import type { ExampleLang } from './helpers/opExample'
-import { liveStrict } from './helpers/testPolicy'
+import { mcpTools, MCP_READ_OPS, MCP_WRITE_OPS } from './helpers/mcpTools'
+import type { McpTool } from './helpers/mcpTools'
+import {
+  primaryOpCall, idLiteral, requiredItems, matchArg, listMatchArg, seededList, dataArg, javaMap, javaMapOf, litFor,
+  litPair,
+} from './helpers/opExample'
+import type { ExampleLang, LiteralLang } from './helpers/opExample'
+import { liveStrict, liveStrictNote, liveFlowNeeds } from './helpers/testPolicy'
+import type { LiveFlowNeeds } from './helpers/testPolicy'
 import { pointSegments, pointParts, pointTerminalParam, pointPathKey }
   from './helpers/pointPath'
 import type { PathSegment } from './helpers/pointPath'
@@ -83,6 +93,7 @@ import {
   featureExcludes,
   fullsetExcludes,
   srcFeatureExcludes,
+  inactiveFeatureExcludes,
   pluginExcludes,
   pluginExcludesFor,
 } from './helpers/featureSource'
@@ -114,6 +125,9 @@ import {
   pkgDescription,
   nonAffiliation,
   keywords,
+  publisherInfo,
+  isDefaultPublisher,
+  securityContact,
   authorInfo,
   contributorList,
   envName,
@@ -131,6 +145,12 @@ import {
   SECURITY_EMAIL,
   GENERATOR_URL,
 } from './helpers/packageMeta'
+import { modelText } from './helpers/text'
+import {
+  npmScriptRm,
+  npmScriptEnv,
+  npmScriptTestSome,
+} from './helpers/npmScripts'
 
 
 import {
@@ -163,6 +183,7 @@ import { edition_add } from './action/edition'
 // The verbs, built from the kind registry — see action/dispatch.
 import { ACTION_MAP, actionNames, needsModel } from './action/dispatch'
 import { KINDS } from './action/kind'
+import { targetOrigins } from './action/resolve'
 
 
 
@@ -203,6 +224,19 @@ type ExternalOverride = {
 const { Jostraca } = JostracaModule
 
 
+// Keeps the define phase's tree, whose File nodes name what a run claims.
+const TreeRoot = JostracaModule.cmp(function TreeRoot(props: any) {
+  props.holder.root = props.ctx$.root
+})
+
+function keepingTree(define: () => any, holder: { root?: any }) {
+  return async () => {
+    await define()
+    TreeRoot({ holder })
+  }
+}
+
+
 // The `const` block every action's model carries, and so what an add
 // substitutes into the copies it writes.
 function projectConst(model: any): any {
@@ -272,12 +306,17 @@ function SdkGen(opts: SdkGenOptions) {
     log.info({ point: 'generate-start', start, note: opts.dryrun ? '** DRY RUN **' : '' })
     log.debug({ point: 'generate-spec', spec })
 
-    // BEFORE ANYTHING READS A NAME. An entity whose name starts with a digit
-    // yields identifiers no target language accepts, and the consumer's own
-    // Root.ts re-derives those names per target — so the only correction that
-    // survives is one made to the model itself, before Root runs. No-op on
-    // every model apidef produces; see helpers/modelNames.
+    // BEFORE ANYTHING READS A NAME. A digit-leading name, or a pair of names
+    // that meet once case is ignored, yields identifiers or files no target
+    // can hold, and the consumer's own Root.ts re-derives those names per
+    // target — so the only correction that survives is one made to the model
+    // itself, before Root runs. See helpers/modelNames.
     guardModelNames(model, log)
+    warnUngeneratedOps(model, log, targetOrigins(model))
+
+    // A flow step whose call the runtime would refuse is switched off, so no
+    // generated test makes it; see helpers/flowGuard.
+    guardFlowSteps(model, log)
 
     let Root = spec.root
 
@@ -325,10 +364,15 @@ function SdkGen(opts: SdkGenOptions) {
 
     checkExternalFolders(external, root, fs)
 
-    const jres = await jostraca.generate(
-      jopts, () => Root({ model: 0 === external.length ? model : withoutExternal(model, external) }))
+    const tree: { root?: any } = {}
+    const jres = await jostraca.generate(jopts, keepingTree(
+      () => Root({ model: 0 === external.length ? model : withoutExternal(model, external) }), tree))
 
     showChanges(jopts.log, 'generate-result', jres, Path.dirname(process.cwd()))
+    pruneGenerated({
+      fs, log, project: root, out: root, jres, claims: claimedFiles(tree.root, folder),
+      dryrun: !!opts.dryrun,
+    })
 
     // Docgen owns editions, destinations, templates, text QA and deployment.
     if (model?.main?.[KIT]?.doc?.active !== false && Object.values(model?.main?.[KIT]?.doc?.edition ?? {})
@@ -358,19 +402,25 @@ function SdkGen(opts: SdkGenOptions) {
 
       const sdkrelpath = externalSdkRel(ext, root, log)
 
+      const etree: { root?: any } = {}
       const eres =
         await jostraca.generate(
         { ...jopts, folder: ext.folder },
-        () => ExternalTarget({
+        keepingTree(() => ExternalTarget({
           model, target: ext.target, cmpfolder: folder,
           // How to walk BACK to the SDK project from the destination. An
           // item generating out of tree usually sits beside the SDK in a
           // known layout, and its own docs, scripts and live tests need to
           // name that path.
           sdkrelpath,
-        }))
+        }), etree))
 
       showChanges(jopts.log, 'generate-result', eres, Path.dirname(process.cwd()))
+      pruneGenerated({
+        fs, log, project: root, out: ext.folder, jres: eres,
+        claims: claimedFiles(etree.root, ext.folder),
+        dryrun: !!opts.dryrun,
+      })
     }
 
     log.info({ point: 'generate-end' })
@@ -938,7 +988,10 @@ function clear(path: string) {
 export type {
   SdkGenOptions,
   ExampleLang,
+  LiteralLang,
+  McpTool,
   DepEntry,
+  LiveFlowNeeds,
   PathSegment,
   FeatureSource,
   DoctorReport,
@@ -962,7 +1015,7 @@ export type {
 type Component = (props: any, children?: any) => void
 
 
-export const cmp: typeof JostracaModule.cmp = JostracaModule.cmp
+export const cmp: typeof JostracaModule.cmp = labelledCmp
 export const names: (base: any, name: string, prop?: string) => any = JostracaModule.names
 export const each: (subject?: any, apply?: any) => any = JostracaModule.each
 export const snakify: (input: any[] | string) => string = JostracaModule.snakify
@@ -1028,6 +1081,10 @@ export {
   boundedFacts,
   hasLiveScenarios,
   definitionPlan,
+  RAW_BODY,
+  bodyNote,
+  opRawBody,
+  opRequestBody,
 
   Jostraca,
   SdkGen,
@@ -1037,6 +1094,7 @@ export {
   resolveAuthPrefix,
   resolveAuthIn,
   resolveAuthName,
+  credentialPlacement,
   isAuthSuppressed,
   isHttpBasicAuth,
   CONFIG_DATA_THRESHOLD,
@@ -1077,6 +1135,9 @@ export {
   OP_SUFFIX,
   opTypeName,
   opParams,
+  opReachable,
+  invalidRequest,
+  opNeedsAction,
   ownPoint,
   opActions,
   entityActions,
@@ -1090,9 +1151,12 @@ export {
   entityClassName,
   entityTypeCollisions,
   warnEntityTypeCollisions,
+  ungeneratedOps,
+  warnUngeneratedOps,
   deriveEntityNames,
   entityCollection,
   guardModelNames,
+  guardFlowSteps,
   projectConst,
   isReservedName,
   safeVarName,
@@ -1110,21 +1174,43 @@ export {
   isTsReservedType,
   isTsSdkType,
   tsSafeTypeName,
+  isElixirReservedType,
+  elixirSafeTypeName,
+  elixirTypeNames,
+  elixirTypeName,
+  elixirAccessorNames,
+  elixirAccessor,
+  tsTypeName,
+  rbTypeName,
+  phpTypeName,
+  swiftTypeName,
+  mcpTools,
+  MCP_READ_OPS,
+  MCP_WRITE_OPS,
   serverVariables,
   hasServerVariables,
   serverVarEnv,
   liveStrict,
+  liveStrictNote,
+  liveFlowNeeds,
   primaryOpCall,
   idLiteral,
+  requiredItems,
   matchArg,
+  listMatchArg,
+  seededList,
+  javaMap,
+  javaMapOf,
   dataArg,
   litFor,
+  litPair,
   featureOf,
   availableFeatures,
   findFeatureSources,
   featureExcludes,
   fullsetExcludes,
   srcFeatureExcludes,
+  inactiveFeatureExcludes,
   pluginExcludes,
   pluginExcludesFor,
   stationLibrary,
@@ -1147,6 +1233,7 @@ export {
   jsProp,
   jsOptProp,
   jsKey,
+  jsQuote,
   luaKey,
   prefixLeadingDigit,
 
@@ -1160,6 +1247,9 @@ export {
   pkgDescription,
   nonAffiliation,
   keywords,
+  publisherInfo,
+  isDefaultPublisher,
+  securityContact,
   authorInfo,
   contributorList,
   envName,
@@ -1176,4 +1266,8 @@ export {
   PUBLISHER_URL,
   SECURITY_EMAIL,
   GENERATOR_URL,
+  modelText,
+  npmScriptRm,
+  npmScriptEnv,
+  npmScriptTestSome,
 }

package/src/testkit.ts

@@ -23,7 +23,8 @@ const SDKGEN_ROOT = Path.resolve(__dirname, '..')
 
 
 const PLACEHOLDERS = [
-  'ProjectName', 'PROJECTNAME', 'PROJECTENV', 'PROJECTVERSION', 'GOMODULE',
+  'ProjectName', 'PROJECTNAME', 'PROJECTENV', 'PROJECTVERSION', 'PROJECTPUBLISHER',
+  'GOMODULE',
 ]
 
 

package/src/utility.ts

@@ -84,6 +84,18 @@ function resolveAuthName(model: any): string {
 }
 
 
+// Where the client sends the API key, when that is not the Authorization header.
+function credentialPlacement(model: any): string {
+  if (!isAuthActive(model)) return ''
+  const where = resolveAuthIn(model)
+  const name = resolveAuthName(model)
+  if ('query' === where) return `The client sends the API key as the \`${name}\` query parameter.`
+  if ('cookie' === where) return `The client sends the API key as the \`${name}\` cookie.`
+  return 'authorization' === name.toLowerCase() ? '' :
+    `The client sends the API key in the \`${name}\` header.`
+}
+
+
 function isHttpBasicAuth(model: any): boolean {
   const auth = getModelPath(model, `main.${KIT}.config.auth`,
     { only_active: false, required: false })
@@ -109,29 +121,42 @@ function resolveAuthExchange(model: any): Record<string, any> | null {
 }
 
 
-function requirePath(ctx$: any, path: string, flags?: { ignore?: boolean }): any {
+// Only a failure to RESOLVE counts as absent. A module that resolves and then
+// throws, from a syntax error, a bug or a missing nested dependency, must
+// propagate, or a broken optional component renders nothing unseen.
+function loadOptional(ctx$: any, path: string): any {
   const fullpath = resolvePath(ctx$, path)
-  const ignore = null == flags?.ignore ? false : flags.ignore
-
-  // When `ignore` is set, only swallow a genuine "module not found"
-  // resolution failure. A module that resolves but throws while loading
-  // (syntax error, runtime bug, or a missing *nested* dependency) must
-  // propagate — otherwise the optional component silently renders nothing
-  // and the real failure is invisible.
-  if (ignore) {
-    try {
-      require.resolve(fullpath)
-    }
-    catch (err: any) {
-      ctx$.log.warn({ point: 'require-missing', path, note: path })
-      return undefined
-    }
+
+  try {
+    require.resolve(fullpath)
+  }
+  catch (err: any) {
+    return undefined
   }
 
   return require(fullpath)
 }
 
 
+function requirePath(ctx$: any, path: string, flags?: { ignore?: boolean }): any {
+  if (!flags?.ignore) {
+    return require(resolvePath(ctx$, path))
+  }
+
+  const found = loadOptional(ctx$, path)
+
+  if (undefined === found) {
+    ctx$.log.warn({
+      point: 'require-missing', path,
+      note: path + ': not found at ' + resolvePath(ctx$, path) +
+        ', so generation continued without it',
+    })
+  }
+
+  return found
+}
+
+
 class SdkGenError extends Error {
   constructor(...args: any[]) {
     super(...args)
@@ -142,11 +167,13 @@ class SdkGenError extends Error {
 
 export {
   resolvePath,
+  loadOptional,
   requirePath,
   isAuthActive,
   resolveAuthPrefix,
   resolveAuthIn,
   resolveAuthName,
+  credentialPlacement,
   isAuthSuppressed,
   resolveAuthExchange,
   isHttpBasicAuth,
@@ -254,7 +281,25 @@ const SPEC_FACTS: Record<string, (model: any) => any> = {
 }
 
 
-function withPointParts(op: any): any {
+// The argument kinds a call routes outside the body.
+const ROUTED_KINDS = ['header', 'cookie', 'query']
+
+
+// The names a point's body keeps when a routed argument shares one: those its
+// JSON request body declares (`bf`), every active field where the model
+// records no `bf`, and never a field the entity marks read-only.
+function bodyFieldNames(pt: any, fields: any[]): string[] {
+  if (false === pt.bf) {
+    return []
+  }
+  const readOnly = fields.filter((f: any) => true === f.ro).map((f: any) => f.n)
+  const names: string[] = Array.isArray(pt.bf) ? pt.bf :
+    fields.filter((f: any) => false !== f.a).map((f: any) => f.n)
+  return names.filter((name) => !readOnly.includes(name))
+}
+
+
+function withPointParts(op: any, fields: any[] = []): any {
   if (null == op) {
     return op
   }
@@ -265,16 +310,19 @@ function withPointParts(op: any): any {
       ...o,
       points: each(o.points).filter((pt: any) => false !== pt?.a).map((pt: any) => {
         if (null == pt) return pt
+        const kept = bodyFieldNames(pt, fields)
         const args = Object.fromEntries(Object.entries(pt.g || {}).map(([kind, values]) =>
           [kind, each(values as any).filter((arg: any) => false !== arg.a).map((arg: any) => ({
             name: arg.n, orig: arg.or, type: arg.t, kind: arg.k,
             reqd: arg.r, example: arg.ex,
+            ...(ROUTED_KINDS.includes(kind) && kept.includes(arg.n) ? { field: true } : {}),
           }))]))
         // Runtime hooks expose descriptive names independently of the model schema.
         return {
           active: pt.a, kind: pt.k, method: pt.m, orig: pt.o,
           segments: pt.s, parts: pointParts(pt), rename: pt.r,
           transform: pt.t, args, select: pt.q, live: pt.li, graphql: pt.gq,
+          body: pt.rb, response: pt.rs,
         }
       }),
     }
@@ -303,14 +351,15 @@ function configDefinition(model: any, targetname?: string): { def: any, json: st
   const entityDefs: any = {}
   const entityStubs: any = {}
   each(entity, (e: any) => {
+    const fields = each(e.fields || {}).filter((f: any) => false !== f.a)
     entityDefs[e.name] = clean({
-      fields: each(e.fields || {}).filter((f: any) => false !== f.a).map((f: any) => ({
+      fields: fields.map((f: any) => ({
         name: f.n, title: f.h, type: f.t, req: f.r, op: f.op,
         short: f.sh, readOnly: f.ro, writeOnly: f.wo, deprecated: f.de, format: f.fo,
       })),
       id: e.id,
       name: e.name,
-      op: withPointParts(e.op),
+      op: withPointParts(e.op, each(e.fields || {})),
       relations: e.relations,
     }, true)
     entityStubs[e.name] = {}

package/project/.sdk/src/cmp/go/fragment/SdkError.fragment.go

@@ -1,22 +0,0 @@
-package ProjectNamePkg
-
-import "fmt"
-
-// ProjectNameError represents an SDK error.
-type ProjectNameError struct {
-	Code    string
-	Message string
-	SDK     string
-}
-
-func (e *ProjectNameError) Error() string {
-	return fmt.Sprintf("%s: %s: %s", e.SDK, e.Code, e.Message)
-}
-
-func NewProjectNameError(code string, msg string) *ProjectNameError {
-	return &ProjectNameError{
-		Code:    code,
-		Message: msg,
-		SDK:     "ProjectName",
-	}
-}

package/project/.sdk/src/cmp/lua/fragment/SdkError.fragment.lua

@@ -1,38 +0,0 @@
--- ProjectName SDK error
-
-local ProjectNameError = {}
-ProjectNameError.__index = ProjectNameError
-
-
-function ProjectNameError.new(code, msg)
-  local self = setmetatable({}, ProjectNameError)
-  self.code = code or ""
-  self.msg = msg or ""
-  self.sdk = "ProjectName"
-
-  -- HTTP status of the response that caused this error, or -1 when the
-  -- request never got one. PROMOTED to the top level: it used to be
-  -- reachable only at `err.result.status`, so every consumer coupled itself
-  -- to the internal shape of `result`.
-  self.status = -1
-
-  return self
-end
-
-
-function ProjectNameError:not_found()
-  return 404 == self.status
-end
-
-
-function ProjectNameError:error()
-  return self.sdk .. ": " .. self.code .. ": " .. self.msg
-end
-
-
-function ProjectNameError:__tostring()
-  return self:error()
-end
-
-
-return ProjectNameError

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

@@ -1,27 +0,0 @@
-# ProjectName SDK error
-
-use strict;
-use warnings;
-
-package ProjectNameError;
-
-use overload
-  '""'     => sub { defined $_[0]->{msg} ? $_[0]->{msg} : '' },
-  'bool'   => sub { 1 },
-  fallback => 1;
-
-sub new {
-  my ($class, $code, $msg) = @_;
-  return bless {
-    code => (defined $code ? $code : ''),
-    msg  => (defined $msg ? $msg : ''),
-    sdk  => 'ProjectName',
-  }, $class;
-}
-
-sub error {
-  my ($self) = @_;
-  return "$self->{sdk}: $self->{code}: $self->{msg}";
-}
-
-1;