@vertz/codegen 0.2.18 → 0.2.19

package/dist/index.d.ts

@@ -168,6 +168,17 @@ interface CodegenRelation {
 	type: "one" | "many";
 	entity: string;
 }
+interface CodegenExposeField {
+	name: string;
+	conditional: boolean;
+}
+interface CodegenExposeRelation {
+	name: string;
+	entity: string;
+	type: "one" | "many";
+	select?: CodegenExposeField[];
+	resolvedFields?: CodegenResolvedField[];
+}
 interface CodegenEntityModule {
 	entityName: string;
 	operations: CodegenEntityOperation[];
@@ -178,6 +189,8 @@ interface CodegenEntityModule {
 	primaryKey?: string;
 	hiddenFields?: string[];
 	responseFields?: CodegenResolvedField[];
+	exposeSelect?: CodegenExposeField[];
+	exposeInclude?: CodegenExposeRelation[];
 	relationSelections?: Record<string, "all" | string[]>;
 	relationQueryConfig?: Record<string, {
 		allowWhere?: string[];

package/dist/index.js

@@ -575,9 +575,17 @@ class EntitySdkGenerator {
       switch (op.kind) {
         case "list": {
           lines.push(`    list: Object.assign(`);
-          lines.push(`      (query?: Record<string, unknown>) => {`);
-          lines.push(`        const resolvedQuery = resolveVertzQL(query);`);
-          lines.push(`        return createDescriptor('GET', '${op.path}', () => client.get<${listOutput}>('${op.path}', { query: resolvedQuery }), resolvedQuery, { entityType: '${entity.entityName}', kind: 'list' as const });`);
+          if (op.outputSchema) {
+            lines.push(`      <K extends keyof ${outputType} = keyof ${outputType}>(`);
+            lines.push(`        query?: { select?: Record<K, true> } & Record<string, unknown>,`);
+            lines.push(`      ) => {`);
+            lines.push(`        const resolvedQuery = resolveVertzQL(query);`);
+            lines.push(`        return createDescriptor('GET', '${op.path}', () => client.get<ListResponse<Pick<${outputType}, K>>>('${op.path}', { query: resolvedQuery }), resolvedQuery, { entityType: '${entity.entityName}', kind: 'list' as const });`);
+          } else {
+            lines.push(`      (query?: Record<string, unknown>) => {`);
+            lines.push(`        const resolvedQuery = resolveVertzQL(query);`);
+            lines.push(`        return createDescriptor('GET', '${op.path}', () => client.get<${listOutput}>('${op.path}', { query: resolvedQuery }), resolvedQuery, { entityType: '${entity.entityName}', kind: 'list' as const });`);
+          }
           lines.push(`      },`);
           lines.push(`      { url: '${op.path}', method: 'GET' as const },`);
           lines.push(`    ),`);
@@ -586,9 +594,17 @@ class EntitySdkGenerator {
         case "get": {
           const getPathExpr = `\`${op.path.replace(":id", "${id}")}\``;
           lines.push(`    get: Object.assign(`);
-          lines.push(`      (id: string, options?: { select?: Record<string, true> }) => {`);
-          lines.push(`        const resolvedQuery = resolveVertzQL(options);`);
-          lines.push(`        return createDescriptor('GET', ${getPathExpr}, () => client.get<${outputType}>(${getPathExpr}, { query: resolvedQuery }), resolvedQuery, { entityType: '${entity.entityName}', kind: 'get' as const, id });`);
+          if (op.outputSchema) {
+            lines.push(`      <K extends keyof ${outputType} = keyof ${outputType}>(`);
+            lines.push(`        id: string, options?: { select?: Record<K, true> },`);
+            lines.push(`      ) => {`);
+            lines.push(`        const resolvedQuery = resolveVertzQL(options);`);
+            lines.push(`        return createDescriptor('GET', ${getPathExpr}, () => client.get<Pick<${outputType}, K>>(${getPathExpr}, { query: resolvedQuery }), resolvedQuery, { entityType: '${entity.entityName}', kind: 'get' as const, id });`);
+          } else {
+            lines.push(`      (id: string, options?: { select?: Record<string, true> }) => {`);
+            lines.push(`        const resolvedQuery = resolveVertzQL(options);`);
+            lines.push(`        return createDescriptor('GET', ${getPathExpr}, () => client.get<${outputType}>(${getPathExpr}, { query: resolvedQuery }), resolvedQuery, { entityType: '${entity.entityName}', kind: 'get' as const, id });`);
+          }
           lines.push(`      },`);
           lines.push(`      { url: '${op.path}', method: 'GET' as const },`);
           lines.push(`    ),`);
@@ -711,7 +727,7 @@ class EntityTypesGenerator {
         }
       }
       if (op.outputSchema && !emitted.has(op.outputSchema)) {
-        const outputType = this.emitResponseType(op.outputSchema, op.responseFields);
+        const outputType = this.emitResponseType(op.outputSchema, op.responseFields, entity);
         if (outputType) {
           lines.push(outputType);
           lines.push("");
@@ -719,6 +735,13 @@ class EntityTypesGenerator {
         }
       }
     }
+    const responseSchema = entity.operations.find((op) => (op.kind === "list" || op.kind === "get") && op.outputSchema)?.outputSchema;
+    if (responseSchema && !emitted.has(`${responseSchema}Fields`)) {
+      const fieldsTypeName = responseSchema.replace(/Response$/, "Fields");
+      lines.push(`export type ${fieldsTypeName} = keyof ${responseSchema};`);
+      lines.push("");
+      emitted.add(`${responseSchema}Fields`);
+    }
     for (const action of entity.actions) {
       if (action.inputSchema && !emitted.has(action.inputSchema)) {
         const inputType = this.emitBodyType(action.inputSchema, action.resolvedInputFields);
@@ -729,7 +752,7 @@ class EntityTypesGenerator {
         }
       }
       if (action.outputSchema && !emitted.has(action.outputSchema)) {
-        const outputType = this.emitResponseType(action.outputSchema, action.resolvedOutputFields);
+        const outputType = this.emitBodyType(action.outputSchema, action.resolvedOutputFields);
         if (outputType) {
           lines.push(outputType);
           lines.push("");
@@ -756,17 +779,38 @@ class EntityTypesGenerator {
 ${props};
 }`;
   }
-  emitResponseType(typeName, fields) {
+  emitResponseType(typeName, fields, entity) {
     if (!fields || fields.length === 0)
       return;
+    const conditionalFields = new Set(entity.exposeSelect?.filter((f) => f.conditional).map((f) => f.name) ?? []);
     const props = fields.map((f) => {
       const tsType = TS_TYPE_MAP[f.tsType] ?? "unknown";
       const optional = f.optional ? "?" : "";
-      return `  ${f.name}${optional}: ${tsType}`;
+      const nullable = conditionalFields.has(f.name) ? " | null" : "";
+      return `  ${f.name}${optional}: ${tsType}${nullable}`;
     }).join(`;
 `);
+    const relationProps = [];
+    if (entity.exposeInclude) {
+      for (const rel of entity.exposeInclude) {
+        if (!rel.resolvedFields || rel.resolvedFields.length === 0)
+          continue;
+        const relFields = rel.resolvedFields.map((f) => {
+          const tsType = TS_TYPE_MAP[f.tsType] ?? "unknown";
+          return `${f.name}: ${tsType}`;
+        }).join("; ");
+        if (rel.type === "many") {
+          relationProps.push(`  ${rel.name}: Array<{ ${relFields} }>`);
+        } else {
+          relationProps.push(`  ${rel.name}?: { ${relFields} }`);
+        }
+      }
+    }
+    const allProps = relationProps.length > 0 ? `${props};
+${relationProps.join(`;
+`)}` : props;
     return `export interface ${typeName} {
-${props};
+${allProps};
 }`;
   }
   generateIndex(entities) {
@@ -1038,6 +1082,19 @@ function adaptIR(appIR) {
     };
   });
   const allSchemas = [...schemas].sort((a, b) => a.name.localeCompare(b.name));
+  const entityResponseFieldsMap = new Map;
+  for (const entity of appIR.entities ?? []) {
+    const respRef = entity.modelRef.schemaRefs.response;
+    if (respRef?.kind === "inline") {
+      const fields = respRef.resolvedFields?.map((f) => ({
+        name: f.name,
+        tsType: f.tsType,
+        optional: f.optional
+      }));
+      if (fields)
+        entityResponseFieldsMap.set(entity.name, fields);
+    }
+  }
   const entities = (appIR.entities ?? []).map((entity) => {
     const entityPascal = toPascalCase(entity.name);
     const operations = [];
@@ -1136,6 +1193,51 @@ function adaptIR(appIR) {
         optional: f.optional
       }));
     }
+    let exposeSelect;
+    let exposeInclude;
+    if (entity.expose) {
+      exposeSelect = entity.expose.select.map((f) => ({
+        name: f.name,
+        conditional: f.conditional
+      }));
+      if (entityResponseFields) {
+        const exposedNames = new Set(entity.expose.select.map((f) => f.name));
+        const hiddenNames = new Set(entity.modelRef.hiddenFields ?? []);
+        entityResponseFields = entityResponseFields.filter((f) => exposedNames.has(f.name) && !hiddenNames.has(f.name));
+        for (const op of operations) {
+          if (op.responseFields) {
+            op.responseFields = op.responseFields.filter((f) => exposedNames.has(f.name) && !hiddenNames.has(f.name));
+          }
+        }
+      }
+      if (entity.expose.include && entity.expose.include.length > 0) {
+        const relationsLookup = new Map(entity.relations.filter((r) => r.type && r.entity).map((r) => [r.name, { type: r.type, entity: r.entity }]));
+        const resolved = [];
+        for (const rel of entity.expose.include) {
+          const relEntity = rel.entity ?? relationsLookup.get(rel.name)?.entity;
+          const relType = rel.type ?? relationsLookup.get(rel.name)?.type;
+          if (!relEntity || !relType)
+            continue;
+          const targetFields = entityResponseFieldsMap.get(relEntity);
+          let resolvedFields;
+          if (targetFields && rel.select) {
+            const selectedNames = new Set(rel.select.map((f) => f.name));
+            resolvedFields = targetFields.filter((f) => selectedNames.has(f.name));
+          } else if (targetFields) {
+            resolvedFields = targetFields;
+          }
+          resolved.push({
+            name: rel.name,
+            entity: relEntity,
+            type: relType,
+            ...rel.select ? { select: rel.select.map((f) => ({ name: f.name, conditional: f.conditional })) } : {},
+            ...resolvedFields ? { resolvedFields } : {}
+          });
+        }
+        if (resolved.length > 0)
+          exposeInclude = resolved;
+      }
+    }
     return {
       entityName: entity.name,
       operations,
@@ -1146,6 +1248,8 @@ function adaptIR(appIR) {
       primaryKey: entity.modelRef.primaryKey,
       hiddenFields: entity.modelRef.hiddenFields,
       responseFields: entityResponseFields,
+      exposeSelect,
+      exposeInclude,
       relationSelections: Object.keys(relationSelections).length > 0 ? relationSelections : undefined,
       relationQueryConfig: Object.keys(relationQueryConfig).length > 0 ? relationQueryConfig : undefined
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/codegen",
-  "version": "0.2.18",
+  "version": "0.2.19",
   "type": "module",
   "license": "MIT",
   "description": "Vertz code generation — internal, no stability guarantee",
@@ -27,7 +27,7 @@
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json"
   },
   "dependencies": {
-    "@vertz/compiler": "^0.2.17"
+    "@vertz/compiler": "^0.2.18"
   },
   "devDependencies": {
     "@types/node": "^25.3.1",