@salsita-ai/sdk 0.50.0-develop.bc08a38ffe → 0.50.0-develop.bcb0516d62

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-domain-block.js

@@ -1,87 +1,83 @@
-import{skipApplicationTypeImports as e}from"../../common/index.js";import{generateComponentOpticsCode as n}from"./generate-component-optics.js";import{generateDefaultsBlock as t}from"./generate-defaults.js";import{generateInvariantsBlock as a}from"./generate-invariants.js";import{generateRelationExpressionsCode as o}from"./generate-relation-expressions.js";import{generateStaticValueCode as i}from"./generate-static-value-code.js";import{generateValueExpressionsCode as s}from"./generate-value-expressions.js";let r="@salsita-ai/sdk/domain",m=(e,n,t)=>{let a=[],o=[];for(let i of e.modelVersion.entitySchemas){let e=JSON.stringify(i.shapeSchema,null,2);a.push(`${t}const ${i.entityType} = new DomainEntityReflection<${n}${i.entityType}>('${i.entityType}', [${e}])`),o.push(String(i.entityType))}return{entityDecls:a.join("\n"),entityNames:o}};export const generateDomainBlock=l=>{let{domainSpec:$,invariants:p,actions:c,typePrefix:d,versionNsPrefix:y,isAdmin:u,modelVersionsExportName:h,relationExpressionsExportName:S,componentOpticsExportName:f,valueExpressionsExportName:D,createRecipeExportName:E,imports:R,registerApplicationTypeImports:A=e}=l;R.addImport(r,"$DomainEntityReflection"),R.addImport(r,"DomainBuilder"),R.addImport(r,"DomainComponentOpticBuilder"),R.addImport(r,"DomainEntityReflection"),R.addImport(r,"EnhancedAliasReflection"),R.addImport(r,"RawAliasReflection"),R.addImport(r,"SchemaReflection"),R.addImport(r,"createCustomExpressionFactory"),R.addImport(r,"createCustomInvariantFactory"),u&&(R.addImport(r,"commonAdminCustomExpressions"),R.addImport(r,"commonAdminViolationExpressions"),R.addImport(r,"createMapPublishedRevisionDataHandlerFactory"),R.addImport(r,"createMapPublishedChunkedDataHandlerFactory"),R.addImport(r,"createDataRowValidatorHandler"),R.addImport(r,"createSheetValidatorHandler")),u||R.addImport(r,"createAssistantSetupHandlerFactory"),R.addTypeImport(r,"RuntimeExpressionContext"),R.addTypeImport(r,"SchemaOfObject"),c&&(R.addImport(r,"createActionFactory"),R.addTypeImport(r,"ActionDefinition"),R.addTypeImport(r,"DomainContextSystems"));let{entityTypes:g,entitySchemas:x}=$.latestModel,v=[...$.latestModel.aliases],j=v.map(([e])=>String(e)),C=j.includes("RootEntity")?"RootEntity":"AnyDomainEntity",{resolvedVersions:I}=$,M=I.latestVersion,H=d?`${d}.`:"",w=new Map([...$.expressions.constants].map(([e,n])=>[String(e),n])),F=(e,n)=>{let t=[...w.get(n)?.keys()??[]],a=t.length>0?`, ${t.map(e=>`'${e}'`).join(" | ")}`:"";return`${e}<${H}$${n}${a}>`},P=e=>{let n=w.get(e);if(!n)return"{}";let t=[...n].map(([e,n])=>{let t=i(n,R).replaceAll("\n","\n    ");return`    ${e}: ${t},`});return`{
+import{skipApplicationTypeImports as e}from"../../common/index.js";import{getDomainFactoryTypes as n}from"./factory-types/index.js";import{generateComponentOpticsCode as t}from"./generate-component-optics.js";import{generateDefaultsBlock as a}from"./generate-defaults.js";import{generateInvariantsBlock as o}from"./generate-invariants.js";import{generateRelationExpressionsCode as i}from"./generate-relation-expressions.js";import{generateStaticValueCode as s}from"./generate-static-value-code.js";import{generateValueExpressionsCode as r}from"./generate-value-expressions.js";let m="@salsita-ai/sdk/domain",l=(e,n,t)=>{let a=[],o=[];for(let i of e.modelVersion.entitySchemas){let e=JSON.stringify(i.shapeSchema,null,2);a.push(`${t}const ${i.entityType} = new DomainEntityReflection<${n}${i.entityType}>('${i.entityType}', [${e}])`),o.push(String(i.entityType))}return{entityDecls:a.join("\n"),entityNames:o}};export const generateDomainBlock=p=>{let{domainSpec:c,invariants:$,actions:d,typePrefix:u,versionNsPrefix:y,isAdmin:h,modelVersionsExportName:f,relationExpressionsExportName:D,componentOpticsExportName:S,valueExpressionsExportName:E,createRecipeExportName:A,imports:R,registerApplicationTypeImports:x=e}=p;R.addImport(m,"$DomainEntityReflection"),R.addImport(m,"DomainBuilder"),R.addImport(m,"DomainComponentOpticBuilder"),R.addImport(m,"DomainEntityReflection"),R.addImport(m,"EnhancedAliasReflection"),R.addImport(m,"RawAliasReflection"),R.addImport(m,"SchemaReflection"),R.addImport(m,"createCustomExpressionFactory"),R.addImport(m,"createCustomInvariantFactory"),h&&(R.addImport(m,"commonAdminCustomExpressions"),R.addImport(m,"commonAdminViolationExpressions"),R.addImport(m,"createMapPublishedRevisionDataHandlerFactory"),R.addImport(m,"createMapPublishedChunkedDataHandlerFactory"),R.addImport(m,"createDataRowValidatorHandler"),R.addImport(m,"createSheetValidatorHandler")),h||R.addImport(m,"createAssistantSetupHandlerFactory"),R.addTypeImport(m,"RuntimeExpressionContext"),R.addTypeImport(m,"SchemaOfObject"),d&&(R.addImport(m,"createActionFactory"),R.addTypeImport(m,"ActionDefinition"),R.addTypeImport(m,"DomainContextSystems"));let{entityTypes:g,entitySchemas:v}=c.latestModel,I=[...c.latestModel.aliases],j=I.map(([e])=>String(e)),C=j.includes("RootEntity")?"RootEntity":"AnyDomainEntity",{resolvedVersions:M}=c,H=M.latestVersion,F=u?`${u}.`:"",P=new Map([...c.expressions.constants].map(([e,n])=>[String(e),n])),b=n(c,u),{enhancedReflectionType:w}=b,T=e=>{let n=P.get(e);if(!n)return"{}";let t=[...n].map(([e,n])=>{let t=s(n,R).replaceAll("\n","\n    ");return`    ${e}: ${t},`});return`{
 ${t.join("\n")}
-  }`},b=x.map(e=>{let n=JSON.stringify(e.shapeSchema,null,2);return`  const ${e.entityType} = new DomainEntityReflection<${H}${e.entityType}>('${e.entityType}', [${n}])`}),k=v.map(([e,n])=>{let t=n.map(String).join(", ");return`  const ${e} = new RawAliasReflection<${H}${e}>('${e}', [${t}])`}),T=[...$.latestModel.commonTypes],V=T.map(([e])=>String(e)),O=I.versionedModels.filter(e=>!e.isLatest).map(e=>`${y}${e.version}`);A(R,[...u?["Admin",...O]:[...g.map(String),...j,...V,...g.map(e=>`$${String(e)}`),...j.map(e=>`$${e}`),"Aliases","$Map",...O,...c?["ActionTypes","NavigationState","ViewState","ToolState","ExportState"]:[]],"PublishedData","SessionData","FrontendData",...u?[]:["BackendData"]]);let B=T.map(([e,n])=>{let t=JSON.stringify(n.runtimeSchema,null,2);return n.schema.enum?.length&&n.schema.enum.every(e=>"string"==typeof e)?`  const ${e}: EnumLike<${H}${e}> = new EnumReflection('${e}', ${t}) as EnumLike<${H}${e}>`:`  const ${e}: SchemaReflection<${H}${e}> = new SchemaReflection('${e}', ${t})`}),N=[...$.latestModel.shapes],J=N.map(([e,n])=>{let t=JSON.stringify(n.runtimeSchema,null,2);return`  const ${e}Shape = new SchemaReflection('${e}Shape', ${t})`}),L=N.map(([e])=>`${e}Shape`),_=j.map(e=>`    ${e}: ${e}.types,`).join("\n"),z=j.map(e=>`    ${e},`).join("\n"),G=V.map(e=>`    ${e},`).join("\n"),q=L.map(e=>`    ${e},`).join("\n"),K=g.map(e=>`    ${e},`).join("\n"),Q=[];for(let[e,n]of $.expressions.expressions)n.size>0&&Q.push(`  const ${e}Expressions = ${JSON.stringify([...n.keys()])}`);let U=g.map(e=>{let n=$.expressions.entityExpressions.get(e),t=(n?.shapeGroups??[]).map(e=>`${e}Expressions`),a=t.length>0?t.map(e=>`...${e}`).join(", "):"",o=F("$DomainEntityReflection",String(e));return`  const $${e}: ${o} = new ${o}('${e}', [${a}], ${P(String(e))})`}).join("\n"),W=g.map(e=>`    ${e}: $${e},`).join("\n"),X=v.map(([e,n])=>{let t=n.map(e=>JSON.stringify(String(e))).join(", "),a=F("EnhancedAliasReflection",String(e));return`  const $${e}: ${a} = new ${a}('$${e}', [${t}], ${P(String(e))})`}).join("\n"),Y=[...g.map(String),...j].map(e=>`    $${e},`).join("\n"),Z=[],ee=[];for(let e of I.versionedModels)if(e.isLatest)Z.push(`  ${e.version}: entities,`),ee.push(`  readonly ${e.version}: {
-${g.map(e=>`    readonly ${String(e)}: DomainEntityReflection<${H}${String(e)}>`).join("\n")}
-  }`);else{let n=`${y}${e.version}.`,{entityDecls:t,entityNames:a}=m(e,n,"    "),o=a.map(e=>`      ${e},`).join("\n");Z.push(`  ${e.version}: (() => {
+  }`},k=v.map(e=>{let n=JSON.stringify(e.shapeSchema,null,2);return`  const ${e.entityType} = new DomainEntityReflection<${F}${e.entityType}>('${e.entityType}', [${n}])`}),O=I.map(([e,n])=>{let t=n.map(String).join(", ");return`  const ${e} = new RawAliasReflection<${F}${e}>('${e}', [${t}])`}),V=[...c.latestModel.commonTypes],B=V.map(([e])=>String(e)),N=M.versionedModels.filter(e=>!e.isLatest).map(e=>`${y}${e.version}`);x(R,[...h?["Admin",...N]:[...g.map(String),...j,...B,...g.map(e=>`$${String(e)}`),...j.map(e=>`$${e}`),"Aliases","$Map",...N,...d?["ActionTypes","NavigationState","ViewState","ToolState","ExportState"]:[]],"PublishedData","SessionData","FrontendData",...h?[]:["BackendData"]]);let J=V.map(([e,n])=>{let t=JSON.stringify(n.runtimeSchema,null,2);return n.schema.enum?.length&&n.schema.enum.every(e=>"string"==typeof e)?`  const ${e}: EnumLike<${F}${e}> = new EnumReflection('${e}', ${t}) as EnumLike<${F}${e}>`:`  const ${e}: SchemaReflection<${F}${e}> = new SchemaReflection('${e}', ${t})`}),L=[...c.latestModel.shapes],_=L.map(([e,n])=>{let t=JSON.stringify(n.runtimeSchema,null,2);return`  const ${e}Shape = new SchemaReflection('${e}Shape', ${t})`}),z=L.map(([e])=>`${e}Shape`),G=j.map(e=>`    ${e}: ${e}.types,`).join("\n"),q=j.map(e=>`    ${e},`).join("\n"),K=B.map(e=>`    ${e},`).join("\n"),Q=z.map(e=>`    ${e},`).join("\n"),U=g.map(e=>`    ${e},`).join("\n"),W=[];for(let[e,n]of c.expressions.expressions)n.size>0&&W.push(`  const ${e}Expressions = ${JSON.stringify([...n.keys()])}`);let X=g.map(e=>{let n=c.expressions.entityExpressions.get(e),t=(n?.shapeGroups??[]).map(e=>`${e}Expressions`),a=t.length>0?t.map(e=>`...${e}`).join(", "):"",o=w("$DomainEntityReflection",String(e));return`  const $${e}: ${o} = new ${o}('${e}', [${a}], ${T(String(e))})`}).join("\n"),Y=g.map(e=>`    ${e}: $${e},`).join("\n"),Z=I.map(([e,n])=>{let t=n.map(e=>JSON.stringify(String(e))).join(", "),a=w("EnhancedAliasReflection",String(e));return`  const $${e}: ${a} = new ${a}('$${e}', [${t}], ${T(String(e))})`}).join("\n"),ee=[...g.map(String),...j].map(e=>`    $${e},`).join("\n"),en=[],et=[];for(let e of M.versionedModels)if(e.isLatest)en.push(`  ${e.version}: entities,`),et.push(`  readonly ${e.version}: {
+${g.map(e=>`    readonly ${String(e)}: DomainEntityReflection<${F}${String(e)}>`).join("\n")}
+  }`);else{let n=`${y}${e.version}.`,{entityDecls:t,entityNames:a}=l(e,n,"    "),o=a.map(e=>`      ${e},`).join("\n");en.push(`  ${e.version}: (() => {
 ${t}
     return {
 ${o}
     } as const
-  })(),`),ee.push(`  readonly ${e.version}: {
+  })(),`),et.push(`  readonly ${e.version}: {
 ${a.map(e=>`    readonly ${e}: DomainEntityReflection<${n}${e}>`).join("\n")}
-  }`)}let en=u?"adminDomainBuilder":"domainBuilder",et=u?"attachAdminComponent":"attachComponent",ea=u?"implementAdminCustomExpressions":"implementCustomExpressions",eo=u?"implementCustomAdminInvariants":"implementCustomInvariants",ei=u?"adminAliases":"aliases",es=u?"adminModel":"model",er=u?"adminEnhancedModel":"enhancedModel",em=u?"implementAdminRelation":"implementRelation",el=u?"__adminDomain":"__configuratorDomain",e$="PublishedData, SessionData, FrontendData",ep=`${H}AnyDomainEntity, ${H}RootEntity, ${H}$Map, ${e$}, ${H}Aliases`,ec=`<${ep}>`,ed=`RuntimeExpressionContext<${H}AnyDomainEntity>`,ey=`<${ep}, ${ed}>`,eu=`DomainContextSystems<${H}AnyDomainEntity, ${H}RootEntity, ${H}$Map, NavigationState, ViewState, ToolState, ExportState>`,eh=a(p,ep,ed,R),eS=(e,n)=>e===n?e:`${e}: ${n}`,ef=[...$.expressions.expressions.values()].some(e=>[...e.values()].some(e=>"relation"===e.implementation.kind));ef&&R.addImport(r,"createRelationFactory");let eD=ef?`
-  const ${em} = createRelationFactory(aliases)
+  }`)}let ea=h?"adminDomainBuilder":"domainBuilder",eo=h?"attachAdminComponent":"attachComponent",ei=h?"implementAdminCustomExpressions":"implementCustomExpressions",es=h?"implementCustomAdminInvariants":"implementCustomInvariants",er=h?"adminAliases":"aliases",em=h?"adminModel":"model",el=h?"adminEnhancedModel":"enhancedModel",ep=h?"implementAdminRelation":"implementRelation",ec=h?"__adminDomain":"__configuratorDomain",e$=b.typeArguments,ed=`<${e$}>`,{contextExtension:eu,systems:ey}=b,eh=`<${e$}, ${eu}>`,ef=o($,e$,eu,R),eD=(e,n)=>e===n?e:`${e}: ${n}`,eS=[...c.expressions.expressions.values()].some(e=>[...e.values()].some(e=>"relation"===e.implementation.kind));eS&&R.addImport(m,"createRelationFactory");let eE=eS?`
+  const ${ep} = createRelationFactory(aliases)
 
-  const relationExpressions = ${o($.expressions,em)}`:"\n  const relationExpressions = {} as const",eE=`
-  const componentOptics = ${n($.components,R)}`,eR=`
-  const valueExpressions = ${s($.expressions,R,"implementCustomExpressions",u?{PresetCategory:"commonAdminCustomExpressions.PresetCategory"}:{})}`;R.addImport(r,"createRecipeFactory");let eA=t($.defaults,R),eg=[...c?.values()??[]].map(e=>({name:String(e.name),...void 0===e.description?{}:{description:e.description},params:e.paramsSchema})),ex=c?`
+  const relationExpressions = ${i(c.expressions,ep)}`:"\n  const relationExpressions = {} as const",eA=`
+  const componentOptics = ${t(c.components,R)}`,eR=`
+  const valueExpressions = ${r(c.expressions,R,"implementCustomExpressions",h?{PresetCategory:"commonAdminCustomExpressions.PresetCategory"}:{})}`;R.addImport(m,"createRecipeFactory");let ex=a(c.defaults,R),eg=[...d?.values()??[]].map(e=>({name:String(e.name),...void 0===e.description?{}:{description:e.description},params:e.paramsSchema})),ev=d?`
   const actionDefinitions: readonly ActionDefinition[] = ${JSON.stringify(eg,null,2).replaceAll("\n","\n  ")}
 
-  const implementActions = createActionFactory<${H}AnyDomainEntity, ${H}RootEntity, ${e$}, ActionTypes, ${ed}, ${eu}>()`:"",ev=`
-  const createRecipe = createRecipeFactory<${H}AnyDomainEntity>(aliases, AnyDomainEntity.reflections, defaults)`,ej=[...g.map(e=>`  readonly ${String(e)}: DomainEntityReflection<${H}${String(e)}>`),...j.map(e=>`  readonly ${e}: RawAliasReflection<${H}${e}>`),...T.map(([e,n])=>{let t=n.schema.enum?.length&&n.schema.enum.every(e=>"string"==typeof e)?"EnumLike":"SchemaReflection";return`  readonly ${e}: ${t}<${H}${e}>`}),...L.map(e=>`  readonly ${e}: SchemaReflection<unknown>`)].join("\n"),eC=`{
-${ej}
-}`,eI=[...g.map(e=>`  readonly $${String(e)}: ${F("$DomainEntityReflection",String(e))}`),...j.map(e=>`  readonly $${e}: ${F("EnhancedAliasReflection",e)}`)].join("\n"),eM=`{
-${eI}
-}`,eH=`{
-${ee.join("\n")}
-}`;return`const ${el} = (() => {
-  const modelVersion = ${M}
-
-  ${eA}
+  const implementActions = createActionFactory<${F}AnyDomainEntity, ${F}RootEntity, PublishedData, SessionData, FrontendData, ActionTypes, ${eu}, ${ey}>()`:"",eI=`
+  const createRecipe = createRecipeFactory<${F}AnyDomainEntity>(aliases, AnyDomainEntity.reflections, defaults)`,{modelType:ej,enhancedModelType:eC}=b,eM=`{
+${et.join("\n")}
+}`;return`const ${ec} = (() => {
+  const modelVersion = ${H}
 
-${b.join("\n")}
+  ${ex}
 
 ${k.join("\n")}
 
-${B.join("\n")}
+${O.join("\n")}
 
 ${J.join("\n")}
 
+${_.join("\n")}
+
   const aliases = {
-${_}
+${G}
   } as const
 
   const entities = {
-${K}
+${U}
   } as const
 
   const model = {
-${K}
-${z}
-${G}
+${U}
 ${q}
+${K}
+${Q}
   } as const
 
-${Q.length>0?Q.join("\n")+"\n":""}
-${U}
+${W.length>0?W.join("\n")+"\n":""}
 ${X}
+${Z}
   const $entityReflections = {
-${W}
+${Y}
   }
 
   const enhancedModel = {
-${Y}
+${ee}
   } as const
 
-  const implementCustomExpressions = createCustomExpressionFactory${ey}()
-${ex}${eD}
+  const implementCustomExpressions = createCustomExpressionFactory${eh}()
+${ev}${eE}
 ${eR}
 
   const modelVersions = {
-${Z.join("\n")}
+${en.join("\n")}
   } as const
-  const attachComponent = DomainComponentOpticBuilder.from${ey}(aliases)
+  const attachComponent = DomainComponentOpticBuilder.from${eh}(aliases)
 
-${eh}
-${u?`  const commonInvariants = implementCustomInvariants(commonAdminViolationExpressions)
+${ef}
+${h?`  const commonInvariants = implementCustomInvariants(commonAdminViolationExpressions)
 
-  const createMapPublishedRevisionDataHandler = createMapPublishedRevisionDataHandlerFactory<${H}AnyDomainEntity, ${H}RootEntity, ${H}$Map, PublishedData>()
-  const createMapPublishedChunkedDataHandler = createMapPublishedChunkedDataHandlerFactory<${H}AnyDomainEntity, ${H}RootEntity, ${H}$Map>()
-`:"\n  const createAssistantSetupHandler = createAssistantSetupHandlerFactory<SessionData, AnyDomainEntity, $Map, ActionTypes>()\n"}${eE}
-${ev}
+  const createMapPublishedRevisionDataHandler = createMapPublishedRevisionDataHandlerFactory<${F}AnyDomainEntity, ${F}RootEntity, ${F}$Map, PublishedData>()
+  const createMapPublishedChunkedDataHandler = createMapPublishedChunkedDataHandlerFactory<${F}AnyDomainEntity, ${F}RootEntity, ${F}$Map>()
+`:"\n  const createAssistantSetupHandler = createAssistantSetupHandlerFactory<SessionData, AnyDomainEntity, $Map, ActionTypes>()\n"}${eA}
+${eI}
 
   return {
-    domainBuilder: DomainBuilder.from${ec}(
+    domainBuilder: DomainBuilder.from${ed}(
       entities,
       aliases,
       $entityReflections,
@@ -90,13 +86,13 @@ ${ev}
       PublishedData,
       SessionData,
       FrontendData,
-      ${u?"undefined":"BackendData"},
-      ${u}
-    ).withExpressions(valueExpressions)${c?".withActions(actionDefinitions)":""},
-    attachComponent,${c?"\n    implementActions,":""}
+      ${h?"undefined":"BackendData"},
+      ${h}
+    ).withExpressions(valueExpressions)${d?".withActions(actionDefinitions)":""},
+    attachComponent,${d?"\n    implementActions,":""}
     implementCustomExpressions,
     implementCustomInvariants,
-    aliases,${u?`
+    aliases,${h?`
     commonInvariants,
     createMapPublishedRevisionDataHandler,
     createMapPublishedChunkedDataHandler,`:"\n    createAssistantSetupHandler,"}
@@ -111,23 +107,23 @@ ${ev}
 })()
 
 const {
-  ${eS("domainBuilder",en)},
-  ${eS("attachComponent",et)},
-  ${eS("implementCustomExpressions",ea)},
-  ${eS("implementCustomInvariants",eo)},
-  ${eS("aliases",ei)},${u?`
+  ${eD("domainBuilder",ea)},
+  ${eD("attachComponent",eo)},
+  ${eD("implementCustomExpressions",ei)},
+  ${eD("implementCustomInvariants",es)},
+  ${eD("aliases",er)},${h?`
   commonInvariants: commonAdminInvariants,
   createMapPublishedRevisionDataHandler,
   createMapPublishedChunkedDataHandler,`:`
   implementActions,
   createAssistantSetupHandler,`}
-  ${eS("relationExpressions",S)},
-  ${eS("valueExpressions",D)},
-  ${eS("componentOptics",f)},
-  ${eS("createRecipe",E)},
-} = ${el}
-
-const ${es}: ${eC} = ${el}.model
-const ${er}: ${eM} = ${el}.enhancedModel
-const ${h}: ${eH} = ${el}.modelVersions
-export { ${en}, ${et}, ${ea}, ${eo}, ${ei}, ${u?"commonAdminInvariants, ":""}${es}, ${er}, ${S}, ${D}, ${f}, ${h}, ${E}${u?", createMapPublishedRevisionDataHandler, createMapPublishedChunkedDataHandler, createDataRowValidatorHandler, createSheetValidatorHandler":", implementActions, createAssistantSetupHandler"} }`};
+  ${eD("relationExpressions",D)},
+  ${eD("valueExpressions",E)},
+  ${eD("componentOptics",S)},
+  ${eD("createRecipe",A)},
+} = ${ec}
+
+const ${em}: ${ej} = ${ec}.model
+const ${el}: ${eC} = ${ec}.enhancedModel
+const ${f}: ${eM} = ${ec}.modelVersions
+export { ${ea}, ${eo}, ${ei}, ${es}, ${er}, ${h?"commonAdminInvariants, ":""}${em}, ${el}, ${D}, ${E}, ${S}, ${f}, ${A}${h?", createMapPublishedRevisionDataHandler, createMapPublishedChunkedDataHandler, createDataRowValidatorHandler, createSheetValidatorHandler":", implementActions, createAssistantSetupHandler"} }`};

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-invariants.d.ts

@@ -1,4 +1,12 @@
 import type { Invariants } from '../../../../parse-application-files/index.js';
 import type { CodeImports } from '../../common/index.js';
+/**
+ * Emits the members of a domain's invariant blueprints: by entity type or alias, each invariant's name
+ * with what it reports (`boolean` for a static invariant, the union of its violation types otherwise).
+ * The custom-invariant factory is closed with them, in `domain-spec.ts` and in the `phx` declarations.
+ *
+ * @param indent The indentation of the members' lines.
+ */
+export declare const generateInvariantBlueprintMembers: (invariants: Invariants, indent: string) => string;
 /** Emits the custom-invariant blueprint and factory declarations for one generated domain block. */
 export declare const generateInvariantsBlock: (invariants: Invariants, factoryGenerics: string, contextExtension: string, imports: CodeImports) => string;

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-invariants.js

@@ -1 +1 @@
-import{stringifyMsgMacroCode as t}from"../../../../core/index.js";let i=(i,o)=>"string"==typeof i?JSON.stringify(i):(o.addImport("@lingui/core/macro","msg"),t(i)),o=t=>"static"===t.kind?"boolean":t.violationTypes.map(t=>JSON.stringify(String(t))).join(" | ");export const generateInvariantsBlock=(t,e,n,r)=>{let{entries:s}=t,a=["  interface CustomInvariantBlueprints {"];for(let[t,i]of Object.entries(s)){for(let[e,n]of(a.push(`    ${t}: {`),Object.entries(i)))a.push(`      ${e}: ${o(n)}`);a.push("    }")}for(let[t,o]of(a.push("  }","  const staticViolations = {"),Object.entries(s))){let e=Object.values(o).filter(t=>"static"===t.kind);if(0!==e.length){for(let o of(a.push(`    ${t}: {`),e)){let t=[`type: ${JSON.stringify(String(o.violationType))}`,`severity: ${JSON.stringify(o.severity)}`,`message: ${i(o.message,r)}`];void 0!==o.controlViolationPriority&&t.push(`controlViolationPriority: ${o.controlViolationPriority}`),a.push(`      ${o.name}: { ${t.join(", ")} },`)}a.push("    },")}}return a.push("  } as const",`  const implementCustomInvariants = createCustomInvariantFactory<${e}, CustomInvariantBlueprints, ${n}>()(staticViolations)`),a.join("\n")};
+import{stringifyMsgMacroCode as t}from"../../../../core/index.js";let e=(e,i)=>"string"==typeof e?JSON.stringify(e):(i.addImport("@lingui/core/macro","msg"),t(e)),i=t=>"static"===t.kind?"boolean":t.violationTypes.map(t=>JSON.stringify(String(t))).join(" | ");export const generateInvariantBlueprintMembers=(t,e)=>{let n=[];for(let[o,r]of Object.entries(t.entries)){for(let[t,s]of(n.push(`${e}${o}: {`),Object.entries(r)))n.push(`${e}  ${t}: ${i(s)}`);n.push(`${e}}`)}return n.join("\n")};export const generateInvariantsBlock=(t,i,n,o)=>{let{entries:r}=t,s=generateInvariantBlueprintMembers(t,"    "),a=["  interface CustomInvariantBlueprints {",...s?[s]:[]];for(let[t,i]of(a.push("  }","  const staticViolations = {"),Object.entries(r))){let n=Object.values(i).filter(t=>"static"===t.kind);if(0!==n.length){for(let i of(a.push(`    ${t}: {`),n)){let t=[`type: ${JSON.stringify(String(i.violationType))}`,`severity: ${JSON.stringify(i.severity)}`,`message: ${e(i.message,o)}`];void 0!==i.controlViolationPriority&&t.push(`controlViolationPriority: ${i.controlViolationPriority}`),a.push(`      ${i.name}: { ${t.join(", ")} },`)}a.push("    },")}}return a.push("  } as const",`  const implementCustomInvariants = createCustomInvariantFactory<${i}, CustomInvariantBlueprints, ${n}>()(staticViolations)`),a.join("\n")};

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-presets.js

@@ -1,3 +1,3 @@
-export const getReferencesTarget=e=>{if(e.references)return e.references;for(let t of["anyOf","oneOf"]){let i=e[t];if(i){for(let e of i)if(e.references)return e.references}}if(e.items){let t=Array.isArray(e.items)?e.items[0]:e.items;if(t)return getReferencesTarget(t)}};export const serializeEntityValue=(e,t,i)=>{if(t&&"string"==typeof e)return`"${e}" as ${i}${t}['id']`;if(t&&Array.isArray(e)){let r=e.map(e=>"string"==typeof e?`"${e}" as ${i}${t}['id']`:JSON.stringify(e));return`[${r.join(", ")}]`}return JSON.stringify(e)};export const generateEntityCode=(e,t,i,r)=>{let n=t.get(e.type),s=[];for(let[t,o]of(s.push(`${i}{`),s.push(`${i}  type: '${e.type}',`),s.push(`${i}  id: "${e.id}" as ${r}${e.type}['id'],`),Object.entries(e.properties))){let e=n?.shapeProperties[t],a=e?getReferencesTarget(e):void 0;s.push(`${i}  ${t}: ${serializeEntityValue(o,a,r)},`)}return s.push(`${i}}`),s.join("\n")};let e=["name","description","img","imgAlt","detailTitle","detailDescription","tags"],t=(t,i)=>e.flatMap(e=>{let r=t[e];return void 0===r?[]:[`${i}${e}: ${JSON.stringify(r)},`]});export const generatePresetsCode=(e,i,r)=>{let{presets:n}=e;if(0===n.length)return;let s=r?`${r}.`:"",o=new Map(i.entitySchemas.map(e=>[String(e.entityType),e])),a=[];for(let e of n){let i=e.initialDomainEntities.map(e=>generateEntityCode(e,o,"        ",s)).join(",\n");a.push(["    {",`      rootEntityType: '${e.rootEntityType}',`,...t(e,"      "),"      initialDomainEntities: [",`${i},`,"      ],","    }"].join("\n"))}return`[
+export const getReferencesTarget=e=>{if(e.references)return e.references;for(let t of["anyOf","oneOf"]){let i=e[t];if(i){for(let e of i)if(e.references)return e.references}}if(e.items){let t=Array.isArray(e.items)?e.items[0]:e.items;if(t)return getReferencesTarget(t)}};export const serializeEntityValue=(e,t,i)=>{if(t&&"string"==typeof e)return`${JSON.stringify(e)} as ${i}${t}['id']`;if(t&&Array.isArray(e)){let r=e.map(e=>"string"==typeof e?`${JSON.stringify(e)} as ${i}${t}['id']`:JSON.stringify(e));return`[${r.join(", ")}]`}return JSON.stringify(e)};export const generateEntityCode=(e,t,i,r)=>{let n=t.get(e.type),s=[];for(let[t,o]of(s.push(`${i}{`),s.push(`${i}  type: '${e.type}',`),s.push(`${i}  id: ${JSON.stringify(e.id)} as ${r}${e.type}['id'],`),Object.entries(e.properties))){let e=n?.shapeProperties[t],a=e?getReferencesTarget(e):void 0;s.push(`${i}  ${t}: ${serializeEntityValue(o,a,r)},`)}return s.push(`${i}}`),s.join("\n")};let e=["name","description","img","imgAlt","detailTitle","detailDescription","tags"],t=(t,i)=>e.flatMap(e=>{let r=t[e];return void 0===r?[]:[`${i}${e}: ${JSON.stringify(r)},`]});export const generatePresetsCode=(e,i,r)=>{let{presets:n}=e;if(0===n.length)return;let s=r?`${r}.`:"",o=new Map(i.entitySchemas.map(e=>[String(e.entityType),e])),a=[];for(let e of n){let i=e.initialDomainEntities.map(e=>generateEntityCode(e,o,"        ",s)).join(",\n");a.push(["    {",`      rootEntityType: '${e.rootEntityType}',`,...t(e,"      "),"      initialDomainEntities: [",`${i},`,"      ],","    }"].join("\n"))}return`[
 ${a.join(",\n")}
   ]`};

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-resources.js

@@ -1,30 +1,30 @@
-import{P as e,match as t}from"ts-pattern";export const generateResourcesLiteral=r=>{let n=r.map(r=>t(r).with({type:"ConfigurationLink"},e=>`  {
+import{P as e,match as t}from"ts-pattern";import{toSingleQuotedString as r}from"../../common/index.js";export const generateResourcesLiteral=n=>{let s=n.map(n=>t(n).with({type:"ConfigurationLink"},e=>`  {
     type: 'ConfigurationLink',
-    name: '${e.name}',
+    name: ${r(e.name)},
   },`).with({type:"Csv"},e=>{let t=e.s3Key?`,
-    s3Key: '${e.s3Key}'`:"";return`  {
+    s3Key: ${r(e.s3Key)}`:"";return`  {
     type: 'Csv',
-    name: '${e.name}'${t},
+    name: ${r(e.name)}${t},
   },`}).with({type:"Pdf"},e=>{let t=e.s3Key?`,
-    s3Key: '${e.s3Key}'`:"";return`  {
+    s3Key: ${r(e.s3Key)}`:"";return`  {
     type: 'Pdf',
-    name: '${e.name}'${t},
+    name: ${r(e.name)}${t},
   },`}).with({type:"Image",clientGenerated:!0,s3Key:e.string},e=>`  {
     type: 'Image',
-    name: '${e.name}',
+    name: ${r(e.name)},
     clientGenerated: true,
-    s3Key: '${e.s3Key}',
+    s3Key: ${r(e.s3Key)},
   },`).with({type:"Image",exists:!0,url:e.string},e=>`  {
     type: 'Image',
-    name: '${e.name}',
+    name: ${r(e.name)},
     exists: true,
-    url: '${e.url}',
+    url: ${r(e.url)},
   },`).with({type:"Image"},e=>`  {
     type: 'Image',
-    name: '${e.name}',
-    s3Key: '${e.s3Key}',
+    name: ${r(e.name)},
+    s3Key: ${r(e.s3Key)},
   },`).exhaustive());return`[
-${n.join("\n")}
+${s.join("\n")}
 ] as const`};export const generateResourcesCodegen=e=>{let t=e.infra.resources;if(void 0===t||0===t.length)return{preBlock:"",builderCall:""};let r=generateResourcesLiteral(t);return{preBlock:`
 // ---- Resources ----
 

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-states.d.ts

@@ -1,5 +1,5 @@
 import type { AdminStates, ConfiguratorStates } from '../../../../parse-application-files/spec/index.js';
-import type { ApplicationTypeImportRegistrar, CodeImports } from '../../common/index.js';
+import { type ApplicationTypeImportRegistrar, type CodeImports } from '../../common/index.js';
 interface StateConstantsProps {
     readonly configuratorStates: ConfiguratorStates;
     readonly adminStates: AdminStates;

package/dist/application-spec/generate-application/code/templates/domain-spec/generate-states.js

@@ -1,2 +1,2 @@
-let e=[{typeName:"NavigationState",key:"navigationStates"},{typeName:"ViewState",key:"viewStates"},{typeName:"ToolState",key:"toolStates"},{typeName:"ExportState",key:"exportStates"}],t=[{typeName:"AdminNavigationState",key:"navigationStates"}],a=e=>{let t=e.values.map(e=>`'${e}'`).join(" | ");return`type ${e.typeName} = ${t}
-const ${e.typeName}: EnumLike<${e.typeName}> = new EnumReflection('${e.typeName}', { enum: ${JSON.stringify(e.values)} }) as EnumLike<${e.typeName}>`},n=e=>`const ${e.typeName}: EnumLike<${e.typeName}> = new EnumReflection('${e.typeName}', { enum: ${JSON.stringify(e.values)} }) as EnumLike<${e.typeName}>`,m=a=>[...e.map(({typeName:e,key:t})=>({typeName:e,values:a.configuratorStates[t]})),...t.map(({typeName:e,key:t})=>({typeName:e,values:a.adminStates[t]}))];export const generateStateConstants=e=>m(e).map(a).join("\n\n");export const generateImportedStateConstants=(e,t,a)=>{let p=m(e);return a(t,p.map(e=>e.typeName)),p.map(n).join("\n\n")};export const generateStateTypeDecls=(a,n)=>{let m=" ".repeat(n);return[...e.map(({typeName:e,key:t})=>{let n=a.configuratorStates[t].map(e=>`'${e}'`).join(" | ");return`${m}type ${e} = ${n}`}),...t.map(({typeName:e,key:t})=>{let n=a.adminStates[t].map(e=>`'${e}'`).join(" | ");return`${m}type ${e} = ${n}`})].join("\n")};
+import{toSingleQuotedString as e}from"../../common/index.js";let t=[{typeName:"NavigationState",key:"navigationStates"},{typeName:"ViewState",key:"viewStates"},{typeName:"ToolState",key:"toolStates"},{typeName:"ExportState",key:"exportStates"}],a=[{typeName:"AdminNavigationState",key:"navigationStates"}],n=t=>{let a=t.values.map(e).join(" | ");return`type ${t.typeName} = ${a}
+const ${t.typeName}: EnumLike<${t.typeName}> = new EnumReflection('${t.typeName}', { enum: ${JSON.stringify(t.values)} }) as EnumLike<${t.typeName}>`},m=e=>`const ${e.typeName}: EnumLike<${e.typeName}> = new EnumReflection('${e.typeName}', { enum: ${JSON.stringify(e.values)} }) as EnumLike<${e.typeName}>`,o=e=>[...t.map(({typeName:t,key:a})=>({typeName:t,values:e.configuratorStates[a]})),...a.map(({typeName:t,key:a})=>({typeName:t,values:e.adminStates[a]}))];export const generateStateConstants=e=>o(e).map(n).join("\n\n");export const generateImportedStateConstants=(e,t,a)=>{let n=o(e);return a(t,n.map(e=>e.typeName)),n.map(m).join("\n\n")};export const generateStateTypeDecls=(n,m)=>{let o=" ".repeat(m);return[...t.map(({typeName:t,key:a})=>{let m=n.configuratorStates[a].map(e).join(" | ");return`${o}type ${t} = ${m}`}),...a.map(({typeName:t,key:a})=>{let m=n.adminStates[a].map(e).join(" | ");return`${o}type ${t} = ${m}`})].join("\n")};

package/dist/application-spec/generate-application/code/templates/domain-spec/index.d.ts

@@ -6,8 +6,9 @@ export { generateComponentOpticsCode } from './generate-component-optics.js';
 export { generateDataSchemaConstants } from './generate-data-schemas.js';
 export { generateChunksSpec, generateDataSpec } from './generate-data-spec.js';
 export { generateDefaultsBlock } from './generate-defaults.js';
+export { getDomainFactoryTypes, type DomainFactoryTypes, type EnhancedReflectionClass } from './factory-types/index.js';
 export { generateDomainBlock, type DomainBlockOptions } from './generate-domain-block.js';
-export { generateInvariantsBlock } from './generate-invariants.js';
+export { generateInvariantBlueprintMembers, generateInvariantsBlock } from './generate-invariants.js';
 export { generateLocaleCodegen } from './generate-locale.js';
 export { generatePhxExportsBlock, generatePhxGlobalsBlock } from './generate-phx-globals.js';
 export { generatePresetsCode } from './generate-presets.js';

package/dist/application-spec/generate-application/code/templates/domain-spec/index.js

@@ -1 +1 @@
-export{generateAclCall}from"./generate-acl.js";export{generateApplicationMetadataBlock}from"./generate-application-metadata.js";export{generateAssistantBlock}from"./generate-assistant.js";export{generateBaseConfiguratorBuilder}from"./generate-base-configurator-builder.js";export{generateComponentOpticsCode}from"./generate-component-optics.js";export{generateDataSchemaConstants}from"./generate-data-schemas.js";export{generateChunksSpec,generateDataSpec}from"./generate-data-spec.js";export{generateDefaultsBlock}from"./generate-defaults.js";export{generateDomainBlock}from"./generate-domain-block.js";export{generateInvariantsBlock}from"./generate-invariants.js";export{generateLocaleCodegen}from"./generate-locale.js";export{generatePhxExportsBlock,generatePhxGlobalsBlock}from"./generate-phx-globals.js";export{generatePresetsCode}from"./generate-presets.js";export{generateRelationExpressionsCode}from"./generate-relation-expressions.js";export{generateMemoEvalPlanCode}from"./generate-memo-eval-plan-code.js";export{generateResourcesLiteral,generateResourcesCodegen}from"./generate-resources.js";export{generateResourcesConfigCall}from"./generate-resources-config.js";export{generateImportedStateConstants,generateStateConstants,generateStateTypeDecls}from"./generate-states.js";export{generateTextLanguagesCall}from"./generate-text-languages.js";
+export{generateAclCall}from"./generate-acl.js";export{generateApplicationMetadataBlock}from"./generate-application-metadata.js";export{generateAssistantBlock}from"./generate-assistant.js";export{generateBaseConfiguratorBuilder}from"./generate-base-configurator-builder.js";export{generateComponentOpticsCode}from"./generate-component-optics.js";export{generateDataSchemaConstants}from"./generate-data-schemas.js";export{generateChunksSpec,generateDataSpec}from"./generate-data-spec.js";export{generateDefaultsBlock}from"./generate-defaults.js";export{getDomainFactoryTypes}from"./factory-types/index.js";export{generateDomainBlock}from"./generate-domain-block.js";export{generateInvariantBlueprintMembers,generateInvariantsBlock}from"./generate-invariants.js";export{generateLocaleCodegen}from"./generate-locale.js";export{generatePhxExportsBlock,generatePhxGlobalsBlock}from"./generate-phx-globals.js";export{generatePresetsCode}from"./generate-presets.js";export{generateRelationExpressionsCode}from"./generate-relation-expressions.js";export{generateMemoEvalPlanCode}from"./generate-memo-eval-plan-code.js";export{generateResourcesLiteral,generateResourcesCodegen}from"./generate-resources.js";export{generateResourcesConfigCall}from"./generate-resources-config.js";export{generateImportedStateConstants,generateStateConstants,generateStateTypeDecls}from"./generate-states.js";export{generateTextLanguagesCall}from"./generate-text-languages.js";

package/dist/application-spec/generate-application/code/templates/eslint-config.d.ts

@@ -1 +1,6 @@
+/**
+ * The project's `eslint.config.js`, written once when the project has none. It re-exports the SDK's
+ * shared ESLint configuration so editors find it in the project root; the project may change it
+ * afterwards. `phoenix check` and `phoenix fix` use the SDK's configuration when the file is missing.
+ */
 export declare const generateApplicationSpecEslintConfig: () => string;

package/dist/application-spec/generate-application/code/templates/eslint-config.js

@@ -1,8 +1,7 @@
-let e=`/**
- * Auto-generated file.
- * Do not modify this file manually.
- * Version: 1
- */`;export const generateApplicationSpecEslintConfig=()=>`${e}
+export const generateApplicationSpecEslintConfig=()=>`/**
+ * The project's ESLint configuration. It re-exports the shared configuration of the Phoenix SDK;
+ * change it to adjust the rules for this project.
+ */
 import { eslintrc } from '@salsita-ai/sdk/common/eslint'
 
 export default eslintrc

package/dist/application-spec/generate-application/code/templates/frontend-config.js

@@ -1,9 +1,7 @@
-import{generateEnvReader as e}from"../common/env-reader.js";import{autoHeader as t}from"../common/file-headers.js";let o={IS_DEV:{type:"bool",default:!1,devDefault:!0},SERVER_URL:{type:"str",devDefault:"http://localhost:3000"},ENVIRONMENT_ID:{type:"str"},DEPLOYMENT_ID:{type:"str"},GTM_ID:{type:"str"},GTM_DEBUG:{type:"bool",default:!1,devDefault:!0},PERSISTENCE_MODE:{type:"str",default:"server",devDefault:"server",choices:["memory","local-storage","server"]},DATADOG_SITE:{type:"str"},DATADOG_CLIENT_TOKEN:{type:"str"},DATADOG_ENABLED:{type:"bool",default:!0,devDefault:!1},SERVICE_NAME:{type:"str",devDefault:"local"},RESOURCES_URL:{type:"str",devDefault:"http://localhost:5173"}},r={CLERK_PUBLISHABLE_KEY:{type:"str",required:!0}};export const generateApplicationSpecFrontendConfig=a=>{let n=a.infra.env?.frontend??{},d=a.appMetadata.useClerk?r:{},{imports:l,config:i}=e({...o,...d,...n}),p=l.length>0?`import { ${l.join(", ")} } from 'envalid'
+import{generateEnvReader as e}from"../common/env-reader.js";import{autoHeader as t}from"../common/file-headers.js";let o={IS_DEV:{type:"bool",default:!1,devDefault:!0},SERVER_URL:{type:"str",devDefault:"http://localhost:3000"},ENVIRONMENT_ID:{type:"str"},DEPLOYMENT_ID:{type:"str"},GTM_ID:{type:"str"},GTM_DEBUG:{type:"bool",default:!1,devDefault:!0},PERSISTENCE_MODE:{type:"str",default:"server",devDefault:"server",choices:["memory","local-storage","server"]},DATADOG_SITE:{type:"str"},DATADOG_CLIENT_TOKEN:{type:"str"},DATADOG_ENABLED:{type:"bool",default:!0,devDefault:!1},SERVICE_NAME:{type:"str",devDefault:"local"},RESOURCES_URL:{type:"str",devDefault:"http://localhost:5173"}},r={CLERK_PUBLISHABLE_KEY:{type:"str",required:!0}};export const generateApplicationSpecFrontendConfig=a=>{let n=a.infra.env?.frontend??{},d=a.appMetadata.useClerk?r:{},{imports:l,config:p}=e({...o,...d,...n}),i=[...l,"createEnvReader"].sort();return`${t("frontend.config.ts","Runtime environment config for the frontend (Vite-injected env vars).")}
+import { ${i.join(", ")} } from '@salsita-ai/sdk/common/env'
 
-`:"";return`${t("frontend.config.ts","Runtime environment config for the frontend (Vite-injected env vars).")}
-${p}import { createEnvReader } from '@salsita-ai/sdk/common/env'
-
-export const readRuntimeConfig = createEnvReader(${i})
+export const readRuntimeConfig = createEnvReader(${p})
 
 export type RuntimeConfig = ReturnType<typeof readRuntimeConfig>
 

package/dist/application-spec/generate-application/code/templates/gitignore.js

@@ -51,9 +51,6 @@ phoenix-api.yaml
 .phoenix
 **/locales/*/*.ts
 phoenix.config.ts
-prettier.config.js
-eslint.config.js
-tsconfig.json
 .prettierignore
 .linguirc
 public/robots.txt

package/dist/application-spec/generate-application/code/templates/global-definition/generate-action-types.js

@@ -1,8 +1,8 @@
-import{schemaToTypeString as e}from"../common/schema-to-type-string.js";let t=(e,t)=>{let n=(e??"").trim().replaceAll("*/","*\\/").split("\n").map(e=>e.trim());return""===n[0]||void 0===n[0]?[]:1===n.length?[`${t}/** ${n[0]} */`]:[`${t}/**`,...n.map(e=>`${t} * ${e}`.trimEnd()),`${t} */`]};export const generateActionTypeDecls=(n,r,o,a,p,s=!1)=>{let i=" ".repeat(p),$=" ".repeat(p+2),c=" ".repeat(p+4),l=" ".repeat(p+6),m={phxDefinitions:o,commonTypeNames:new Set(r.commonTypes.keys()),imports:a,typeOnlyImports:s},y=[...n.values()].map(n=>{let r=Object.entries(n.params).flatMap(([n,{schema:r,required:o}])=>[...t(r.description,l),`${l}readonly ${n}${o?"":"?"}: ${e(r,m)}`]),o=Object.entries(n.result).flatMap(([n,r])=>[...t(r.description,l),`${l}readonly ${n}: ${e(r,m)}`]),a=e=>e.length>0?`{
+import{docComment as e}from"../common/doc-comment.js";import{schemaToTypeString as t}from"../common/schema-to-type-string.js";export const generateActionTypeDecls=(n,o,r,a,s,p=!1)=>{let c=" ".repeat(s),i=" ".repeat(s+2),m=" ".repeat(s+4),$=" ".repeat(s+6),y={phxDefinitions:r,commonTypeNames:new Set(o.commonTypes.keys()),imports:a,typeOnlyImports:p},l=[...n.values()].map(n=>{let o=Object.entries(n.params).flatMap(([n,{schema:o,required:r}])=>[...e(o.description,$),`${$}readonly ${n}${r?"":"?"}: ${t(o,y)}`]),r=Object.entries(n.result).flatMap(([n,o])=>[...e(o.description,$),`${$}readonly ${n}: ${t(o,y)}`]),a=e=>e.length>0?`{
 ${e.join("\n")}
-${c}}`:"Record<string, never>";return[...t(n.description,$),`${$}readonly ${n.name}: {`,`${c}readonly params: ${a(r)}`,`${c}readonly result: ${a(o)}`,`${$}}`].join("\n")}),A=y.length>0?`{
-${y.join("\n")}
-${i}}`:"Record<never, never>";return`${i}type ActionTypes = ${A}
-${i}type ActionName = keyof ActionTypes
-${i}type ActionParams<NAME extends ActionName> = ActionTypes[NAME]['params']
-${i}type ActionResult<NAME extends ActionName> = ActionTypes[NAME]['result']`};
+${m}}`:"Record<string, never>";return[...e(n.description,i),`${i}readonly ${n.name}: {`,`${m}readonly params: ${a(o)}`,`${m}readonly result: ${a(r)}`,`${i}}`].join("\n")}),A=l.length>0?`{
+${l.join("\n")}
+${c}}`:"Record<never, never>";return`${c}type ActionTypes = ${A}
+${c}type ActionName = keyof ActionTypes
+${c}type ActionParams<NAME extends ActionName> = ActionTypes[NAME]['params']
+${c}type ActionResult<NAME extends ActionName> = ActionTypes[NAME]['result']`};

package/dist/application-spec/generate-application/code/templates/global-definition/generate-assistant-form-element-types.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantFormElementDescriptor } from '#package/domain';
+import type { PhoenixDefinitions } from '../../../../core/phoenix-definitions.js';
+import type { CodeImports } from '../../common/code-imports.js';
+/**
+ * Generates the `AssistantFormElementTypes` map of the project's own assistant form elements (name →
+ * `{ role, attributes }`), and the `AssistantFormElementName` and `AssistantFormElementProps<NAME>`
+ * types derived from it, which `phx.frontend.createAssistantFormElement` is typed by. An attribute
+ * outside `required` is optional and an enum is a union of its values. The `description` of an element becomes the doc
+ * comment of its property. Without elements the map is empty, so `AssistantFormElementName` is
+ * `never`.
+ */
+export declare const generateAssistantFormElementTypeDecls: (formElements: readonly AssistantFormElementDescriptor[], phxDefinitions: PhoenixDefinitions, imports: CodeImports, indent: number) => string;

package/dist/application-spec/generate-application/code/templates/global-definition/generate-assistant-form-element-types.js

@@ -0,0 +1,7 @@
+import{docComment as e}from"../common/doc-comment.js";import{formatPropertyKey as t}from"../common/format-property-key.js";import{schemaToTypeString as n}from"../common/schema-to-type-string.js";export const generateAssistantFormElementTypeDecls=(o,r,s,m)=>{let a=" ".repeat(m),p=" ".repeat(m+2),l=" ".repeat(m+4),i=" ".repeat(m+6),$={phxDefinitions:r,commonTypeNames:new Set,imports:s},y=o.map(({name:o,role:r,description:s,attributes:m,required:a=[]})=>{let y=Object.entries(m).map(([e,o])=>`${i}readonly ${t(e)}${a.includes(e)?"":"?"}: ${n({...o},$)}`);return[...e(s,p),`${p}readonly ${t(o)}: {`,`${l}readonly role: '${r}'`,`${l}readonly attributes: ${y.length>0?`{
+${y.join("\n")}
+${l}}`:"Record<never, never>"}`,`${p}}`].join("\n")});s.addTypeImport("@salsita-ai/sdk/configurator","AssistantFormElementRoleProps");let c=y.length>0?`{
+${y.join("\n")}
+${a}}`:"Record<never, never>";return`${a}type AssistantFormElementTypes = ${c}
+${a}type AssistantFormElementName = keyof AssistantFormElementTypes
+${a}type AssistantFormElementProps<NAME extends AssistantFormElementName, STATE = unknown> = AssistantFormElementRoleProps<AssistantFormElementTypes[NAME], STATE>`};

package/dist/application-spec/generate-application/code/templates/global-definition/generate-phx-types.d.ts

@@ -0,0 +1,43 @@
+import type { ApplicationSpec } from '../../../../parse-application-files/index.js';
+import type { CodeImports } from '../../common/index.js';
+/**
+ * The types of the `phx` members, stated from SDK types and the project's generated types alone.
+ *
+ * Each member that the generated code builds with an SDK factory is declared as that factory's
+ * result for the type arguments the generated call states (`ReturnType<typeof factory<…>>`), so the
+ * declared type is the very type of the generated value; each member that is an SDK function as is
+ * is declared as that function's type; the model reflections are declared member by member.
+ *
+ * The factory results are named by type aliases local to the declaring file, and the members refer
+ * to those names. An editor cannot name a local alias where `phx` is used, so it shows the type
+ * itself, as it did when the members referred to the generated values; a member written as
+ * `ReturnType<typeof factory<…>>` in place would be shown as written, and printing it overflows the
+ * stack of the TypeScript 6 type printer.
+ */
+export interface PhxTypes {
+    /** Declarations the member types refer to, to emit once beside them, outside `declare global`. */
+    readonly declarations: string;
+    /** `phx.domain`, its admin part included. */
+    readonly domainType: string;
+    /** `phx.frontend` without its admin part. */
+    readonly configuratorInterfaceType: string;
+    /** The generated application types the member types refer to. */
+    readonly applicationTypeNames: readonly string[];
+}
+/** The types of a generated project's global `phx`, which also has `phx.frontend.admin` and `phx.webhooks`. */
+export interface GlobalPhxTypes extends PhxTypes {
+    /** `phx.frontend.admin`. */
+    readonly adminInterfaceType: string;
+    /** `phx.webhooks`. */
+    readonly webhooksType: string;
+}
+/**
+ * Generates the types of the `phx` members a story's module binding has (`domain` and
+ * `frontend`) and registers the SDK imports they need.
+ */
+export declare const generatePhxTypes: (spec: ApplicationSpec, imports: CodeImports) => PhxTypes;
+/**
+ * Generates the types of the members of a generated project's global `phx`, `phx.frontend.admin` and
+ * `phx.webhooks` included, and registers the SDK imports they need.
+ */
+export declare const generateGlobalPhxTypes: (spec: ApplicationSpec, imports: CodeImports) => GlobalPhxTypes;

package/dist/application-spec/generate-application/code/templates/global-definition/generate-phx-types.js

@@ -0,0 +1,33 @@
+import{generateInvariantBlueprintMembers as e,getDomainFactoryTypes as t}from"../domain-spec/index.js";let a="@salsita-ai/sdk/configurator",n="CustomInvariantBlueprints",o="AdminCustomInvariantBlueprints",i=["authHandlerBuilder","webhookBuilder","taskFactory","finalizeHandlerBuilder","callbackBuilder","prefetchBuilder","dynamicResourcesFactory"],r=(e,t)=>e.replaceAll("\n",`
+${t}`),s=e=>{let t=(e.infra.resources??[]).map(e=>JSON.stringify(e.name));return["AnyDomainEntity","RootEntity","$Map","NavigationState","ViewState","ToolState","ExportState","PublishedData","SessionData","FrontendData","Admin.AnyDomainEntity","Admin.RootEntity","Admin.$Map","AdminNavigationState","never","FinalizeData","PrefetchedFinalizeData","FinalizeResult","CallbackData",t.length>0?[...new Set(t)].join(" | "):"never"].join(", ")},l=()=>{let e=new Map;return{member:(t,a)=>(e.set(t,a),t),declarations:()=>[...e].map(([e,t])=>`type ${e} = ${t}`).join("\n")}},d=(i,l,d)=>{for(let e of["$DomainEntityReflection","DomainComponentOpticBuilder","DomainContextSystems","DomainEntityReflection","EnhancedAliasReflection","EnumLike","RawAliasReflection","RuntimeExpressionContext","SchemaReflection","createActionFactory","createAssistantSetupHandlerFactory","createCustomExpressionFactory","createCustomInvariantFactory","createDataRowValidatorHandler","createMapPublishedChunkedDataHandlerFactory","createMapPublishedRevisionDataHandlerFactory","createRecipeFactory","createSheetValidatorHandler"])l.addTypeImport("@salsita-ai/sdk/domain",e);l.addTypeImport(a,"createConfiguratorInterface"),l.addTypeImport(a,"CreateAssistantFormElement");let p=t(i.configurator,""),m=t(i.admin,"Admin"),y=s(i),c=(e,t)=>t?`interface ${e} {
+${t}
+}`:`interface ${e} {}`,{member:u}=d,$=`{
+  readonly model: ${r(p.modelType,"  ")}
+  readonly enhancedModel: ${r(p.enhancedModelType,"  ")}
+  readonly implementCustomExpressions: ${u("PhxImplementCustomExpressions",`ReturnType<typeof createCustomExpressionFactory<${p.typeArguments}, ${p.contextExtension}>>`)}
+  readonly implementCustomInvariants: ${u("PhxImplementCustomInvariants",`ReturnType<ReturnType<typeof createCustomInvariantFactory<${p.typeArguments}, ${n}, ${p.contextExtension}>>>`)}
+  readonly implementActions: ${u("PhxImplementActions",`ReturnType<typeof createActionFactory<AnyDomainEntity, RootEntity, PublishedData, SessionData, FrontendData, ActionTypes, ${p.contextExtension}, ${p.systems}>>`)}
+  readonly createAssistantSetupHandler: ${u("PhxCreateAssistantSetupHandler","ReturnType<typeof createAssistantSetupHandlerFactory<SessionData, AnyDomainEntity, $Map, ActionTypes>>")}
+  readonly attachComponent: ${u("PhxAttachComponent",`ReturnType<typeof DomainComponentOpticBuilder.from<${p.typeArguments}, ${p.contextExtension}>>`)}
+  readonly createRecipe: ${u("PhxCreateRecipe","ReturnType<typeof createRecipeFactory<AnyDomainEntity>>")}
+  readonly admin: {
+    readonly model: ${r(m.modelType,"    ")}
+    readonly enhancedModel: ${r(m.enhancedModelType,"    ")}
+    readonly implementCustomExpressions: ${u("PhxAdminImplementCustomExpressions",`ReturnType<typeof createCustomExpressionFactory<${m.typeArguments}, ${m.contextExtension}>>`)}
+    readonly implementCustomInvariants: ${u("PhxAdminImplementCustomInvariants",`ReturnType<ReturnType<typeof createCustomInvariantFactory<${m.typeArguments}, ${o}, ${m.contextExtension}>>>`)}
+    readonly attachComponent: ${u("PhxAdminAttachComponent",`ReturnType<typeof DomainComponentOpticBuilder.from<${m.typeArguments}, ${m.contextExtension}>>`)}
+    readonly createMapPublishedRevisionDataHandler: ${u("PhxAdminCreateMapPublishedRevisionDataHandler","ReturnType<typeof createMapPublishedRevisionDataHandlerFactory<Admin.AnyDomainEntity, Admin.RootEntity, Admin.$Map, PublishedData>>")}
+    readonly createMapPublishedChunkedDataHandler: ${u("PhxAdminCreateMapPublishedChunkedDataHandler","ReturnType<typeof createMapPublishedChunkedDataHandlerFactory<Admin.AnyDomainEntity, Admin.RootEntity, Admin.$Map>>")}
+    readonly createDataRowValidatorHandler: typeof createDataRowValidatorHandler
+    readonly createSheetValidatorHandler: typeof createSheetValidatorHandler
+    readonly createRecipe: ${u("PhxAdminCreateRecipe","ReturnType<typeof createRecipeFactory<Admin.AnyDomainEntity>>")}
+  }
+}`,A=u("PhxFrontend",`ReturnType<typeof createConfiguratorInterface<${y}>> & {
+  readonly createAssistantFormElement: CreateAssistantFormElement<AssistantFormElementTypes>
+}`),{latestModel:h}=i.configurator;return{declarations:[c(n,e(i.configurator.invariants,"  ")),c(o,e(i.admin.invariants,"  "))].join("\n\n"),domainType:$,configuratorInterfaceType:A,applicationTypeNames:[...h.entityTypes.map(String),...[...h.aliases].map(([e])=>String(e)),...[...h.commonTypes].map(([e])=>String(e)),...h.entityTypes.map(e=>`$${String(e)}`),...[...h.aliases].map(([e])=>`$${String(e)}`),"Aliases","$Map","ActionTypes","AssistantFormElementTypes","Admin","PublishedData","SessionData","FrontendData","BackendData","FinalizeData","PrefetchedFinalizeData","FinalizeResult","CallbackData","NavigationState","ViewState","ToolState","ExportState","AdminNavigationState"]}};export const generatePhxTypes=(e,t)=>{let a=l(),n=d(e,t,a);return{...n,declarations:`${n.declarations}
+
+${a.declarations()}`}};export const generateGlobalPhxTypes=(e,t)=>{let a=l(),{member:n}=a,o=d(e,t,a);t.addTypeImport("@salsita-ai/sdk/admin","createAdminInterface"),t.addTypeImport("@salsita-ai/sdk/webhook","createDomainWebhook");let r=s(e),p=n("PhxFrontendAdmin",`ReturnType<typeof createAdminInterface<${r}>>`),m=n("PhxWebhookBuilders",`ReturnType<typeof createDomainWebhook<${r}>>`),y=i.map(e=>`  readonly ${e}: ${n(`PhxWebhooks${e.charAt(0).toUpperCase()}${e.slice(1)}`,`${m}['${e}']`)}`);return{...o,declarations:`${o.declarations}
+
+${a.declarations()}`,adminInterfaceType:p,webhooksType:`{
+${y.join("\n")}
+}`}};

package/dist/application-spec/generate-application/code/templates/global-definition/index.d.ts

@@ -1,4 +1,6 @@
 export { generateActionTypeDecls } from './generate-action-types.js';
+export { generateAssistantFormElementTypeDecls } from './generate-assistant-form-element-types.js';
 export { generateModelTypeDecls } from './generate-model-types.js';
 export { generateExpressionTypeDecls, generateEntityExpressionComposites } from './generate-expression-types.js';
 export { generateDataSchemaTypeDecls } from './generate-data-schema-types.js';
+export { generateGlobalPhxTypes, generatePhxTypes, type GlobalPhxTypes, type PhxTypes } from './generate-phx-types.js';

package/dist/application-spec/generate-application/code/templates/global-definition/index.js

@@ -1 +1 @@
-export{generateActionTypeDecls}from"./generate-action-types.js";export{generateModelTypeDecls}from"./generate-model-types.js";export{generateExpressionTypeDecls,generateEntityExpressionComposites}from"./generate-expression-types.js";export{generateDataSchemaTypeDecls}from"./generate-data-schema-types.js";
+export{generateActionTypeDecls}from"./generate-action-types.js";export{generateAssistantFormElementTypeDecls}from"./generate-assistant-form-element-types.js";export{generateModelTypeDecls}from"./generate-model-types.js";export{generateExpressionTypeDecls,generateEntityExpressionComposites}from"./generate-expression-types.js";export{generateDataSchemaTypeDecls}from"./generate-data-schema-types.js";export{generateGlobalPhxTypes,generatePhxTypes}from"./generate-phx-types.js";