Enhance typegen configuration and UI components

- Updated typegen configuration to support field and table-level overrides, allowing for more granular control over generated types.
- Introduced a new metadata.xml file to manage schema metadata, improving validation and user experience.
- Enhanced the MetadataFieldsDialog and MetadataTablesEditor components with new features for field exclusion and type overrides.
- Improved state management and user interactions in the UI, including the ability to include/exclude fields and tables easily.
- Refactored data grid components for better performance and usability, ensuring a smoother user experience.

Author: eluce2

.gitignore

@@ -72,3 +72,4 @@ server/dist
 public/dist
 .turbo
 packages/fmdapi/test/typegen/*
+packages/typegen/schema/metadata.xml

packages/typegen/proofkit-typegen.config.jsonc

@@ -15,7 +15,31 @@
       "path": "schema",
       "metadataPath": "schema/metadata.xml",
       "downloadMetadata": true,
-      "clearOldFiles": false
+      "clearOldFiles": false,
+      "tables": [
+        {
+          "tableName": "customer",
+          "fields": [
+            {
+              "fieldName": "ModificationTimestamp",
+              "exclude": true
+            },
+            {
+              "fieldName": "ModifiedBy",
+              "exclude": true
+            }
+          ]
+        },
+        {
+          "tableName": "contacts",
+          "fields": [
+            {
+              "fieldName": "hobby",
+              "exclude": true
+            }
+          ]
+        }
+      ]
     }
   ]
 }

packages/typegen/schema/metadata.xml

@@ -12,10 +12,55 @@ interface GeneratedTO {
   needsZod: boolean;
 }
 
+/**
+ * Maps type override enum values to field builder functions from @proofkit/fmodata
+ */
+function mapTypeOverrideToFieldBuilder(
+  typeOverride:
+    | "text"
+    | "number"
+    | "boolean"
+    | "fmBooleanNumber"
+    | "date"
+    | "timestamp"
+    | "container",
+): string {
+  switch (typeOverride) {
+    case "text":
+      return "textField()";
+    case "number":
+      return "numberField()";
+    case "boolean":
+    case "fmBooleanNumber":
+      return "numberField().outputValidator(z.coerce.boolean())";
+    case "date":
+      return "dateField()";
+    case "timestamp":
+      return "timestampField()";
+    case "container":
+      return "containerField()";
+  }
+}
+
 /**
  * Maps OData types to field builder functions from @proofkit/fmodata
  */
-function mapODataTypeToFieldBuilder(edmType: string): string {
+function mapODataTypeToFieldBuilder(
+  edmType: string,
+  typeOverride?:
+    | "text"
+    | "number"
+    | "boolean"
+    | "fmBooleanNumber"
+    | "date"
+    | "timestamp"
+    | "container",
+): string {
+  // If typeOverride is provided, use it instead of the inferred type
+  if (typeOverride) {
+    return mapTypeOverrideToFieldBuilder(typeOverride);
+  }
+
   switch (edmType) {
     case "Edm.String":
       return "textField()";
@@ -62,6 +107,7 @@ function generateTableOccurrence(
   entitySetName: string,
   entityType: EntityType,
   entityTypeToSetMap: Map<string, string>,
+  tableOverride?: NonNullable<FmodataConfig["tables"]>[number],
 ): GeneratedTO {
   const fmtId = entityType["@TableID"];
   const keyFields = entityType.$Key || [];
@@ -121,14 +167,60 @@ function generateTableOccurrence(
     idField = autoGenField ?? idFieldName ?? firstFieldName;
   }
 
+  // Build a field overrides map from the array for easier lookup
+  type FieldOverrideType = Exclude<
+    NonNullable<NonNullable<FmodataConfig["tables"]>[number]>["fields"],
+    undefined
+  >[number];
+  const fieldOverridesMap = new Map<string, FieldOverrideType>();
+  if (tableOverride?.fields) {
+    for (const fieldOverride of tableOverride.fields) {
+      if (fieldOverride?.fieldName) {
+        fieldOverridesMap.set(fieldOverride.fieldName, fieldOverride);
+      }
+    }
+  }
+
   // Generate field builder definitions
   const fieldLines: string[] = [];
   const fieldEntries = Array.from(fields.entries());
-  for (let i = 0; i < fieldEntries.length; i++) {
-    const entry = fieldEntries[i];
+
+  // Filter out excluded fields and collect valid entries
+  const validFieldEntries: Array<
+    [string, typeof fields extends Map<infer K, infer V> ? V : never]
+  > = [];
+  for (const entry of fieldEntries) {
+    if (!entry) continue;
+    const [fieldName] = entry;
+    const fieldOverride = fieldOverridesMap.get(fieldName);
+
+    // Skip excluded fields
+    if (fieldOverride?.exclude === true) {
+      continue;
+    }
+
+    validFieldEntries.push(entry);
+  }
+
+  for (let i = 0; i < validFieldEntries.length; i++) {
+    const entry = validFieldEntries[i];
     if (!entry) continue;
     const [fieldName, metadata] = entry;
-    const fieldBuilder = mapODataTypeToFieldBuilder(metadata.$Type);
+    const fieldOverride = fieldOverridesMap.get(fieldName);
+
+    // Apply typeOverride if provided, otherwise use inferred type
+    const fieldBuilder = mapODataTypeToFieldBuilder(
+      metadata.$Type,
+      fieldOverride?.typeOverride as
+        | "text"
+        | "number"
+        | "boolean"
+        | "fmBooleanNumber"
+        | "date"
+        | "timestamp"
+        | "container"
+        | undefined,
+    );
 
     // Track which field builders are used
     if (fieldBuilder.includes("textField()")) {
@@ -153,7 +245,7 @@ function generateTableOccurrence(
     // metadata.$Nullable is false only if Nullable="false" was in XML, otherwise it's true (nullable by default)
     const isExplicitlyNotNullable = metadata.$Nullable === false;
     const isReadOnly = readOnlyFields.includes(fieldName);
-    const isLastField = i === fieldEntries.length - 1;
+    const isLastField = i === validFieldEntries.length - 1;
 
     let line = `    ${JSON.stringify(fieldName)}: ${fieldBuilder}`;
 
@@ -181,7 +273,10 @@ function generateTableOccurrence(
     fieldLines.push(line);
   }
 
-  const varName = entitySetName.replace(/[^a-zA-Z0-9_]/g, "_");
+  // Apply variableName override if provided, otherwise generate from entitySetName
+  const varName = tableOverride?.variableName
+    ? tableOverride.variableName.replace(/[^a-zA-Z0-9_]/g, "_")
+    : entitySetName.replace(/[^a-zA-Z0-9_]/g, "_");
 
   // Build options object
   const optionsParts: string[] = [];
@@ -269,7 +364,7 @@ export async function generateODataTypes(
   config: FmodataConfig,
 ): Promise<void> {
   const { entityTypes, entitySets } = metadata;
-  const { path, clearOldFiles = true } = config;
+  const { path, clearOldFiles = true, tables } = config;
   const outputPath = path ?? "schema";
 
   // Build a map from entity type name to entity set name
@@ -278,16 +373,38 @@ export async function generateODataTypes(
     entityTypeToSetMap.set(entitySet.EntityType, entitySetName);
   }
 
+  // Build a table overrides map from the array for easier lookup
+  const tableOverridesMap = new Map<
+    string,
+    NonNullable<FmodataConfig["tables"]>[number]
+  >();
+  if (tables) {
+    for (const tableOverride of tables) {
+      if (tableOverride?.tableName) {
+        tableOverridesMap.set(tableOverride.tableName, tableOverride);
+      }
+    }
+  }
+
   // Generate table occurrences for entity sets
   const generatedTOs: GeneratedTO[] = [];
 
   for (const [entitySetName, entitySet] of entitySets.entries()) {
+    // Get table override config if it exists
+    const tableOverride = tableOverridesMap.get(entitySetName);
+
+    // Skip excluded tables
+    if (tableOverride?.exclude === true) {
+      continue;
+    }
+
     const entityType = entityTypes.get(entitySet.EntityType);
     if (entityType) {
       const generated = generateTableOccurrence(
         entitySetName,
         entityType,
         entityTypeToSetMap,
+        tableOverride,
       );
       generatedTOs.push(generated);
     }

packages/typegen/src/fmodata/generateODataTypes.ts

@@ -1,5 +1,4 @@
 import { Hono } from "hono";
-import { logger } from "hono/logger";
 import { zValidator } from "@hono/zod-validator";
 import fs from "fs-extra";
 import path from "path";
@@ -22,12 +21,6 @@ export interface ApiContext {
   configPath: string;
 }
 
-export const devOnlyLogger = (message: string, ...rest: string[]) => {
-  if (process.env.NODE_ENV === "development") {
-    console.log(message, ...rest);
-  }
-};
-
 /**
  * Flattens a nested layout/folder structure into a flat list with full paths
  */
@@ -61,7 +54,6 @@ function flattenLayouts(
 export function createApiApp(context: ApiContext) {
   // Define all routes with proper chaining for type inference
   const app = new Hono()
-    .use(logger(devOnlyLogger))
     .basePath("/api")
 
     // GET /api/config

packages/typegen/src/server/app.ts

@@ -173,10 +173,6 @@ export function createOdataClientFromConfig(
   }
   const { server, db: dbName, authType, auth } = result;
 
-  console.log("server", server);
-  console.log("dbName", dbName);
-  console.log("authType", authType);
-  console.log("auth", auth);
   const connection = new FMServerConnection({
     serverUrl: server,
     auth,

packages/typegen/src/server/createDataApiClient.ts

@@ -87,6 +87,62 @@ const path = z
   .optional()
   .meta({ description: "The folder path to output the generated files" });
 
+// Field-level override configuration
+const fieldOverride = z
+  .object({
+    // Field name to apply override to
+    fieldName: z.string().meta({
+      description: "The field name this override applies to",
+    }),
+    // Exclude this field from generation
+    exclude: z.boolean().optional().meta({
+      description: "If true, this field will be excluded from generation",
+    }),
+    // Override the inferred type from metadata
+    typeOverride: z
+      .enum([
+        "text", // textField()
+        "number", // numberField()
+        "boolean", // numberField().outputValidator(z.coerce.boolean())
+        "fmBooleanNumber", // Same as boolean, explicit FileMaker 0/1 pattern
+        "date", // dateField()
+        "timestamp", // timestampField()
+        "container", // containerField()
+      ])
+      .optional()
+      .meta({
+        description:
+          "Override the inferred field type from metadata. Options: text, number, boolean, fmBooleanNumber, date, timestamp, container",
+      }),
+  })
+  .optional();
+
+// Table-level override configuration
+const tableOverride = z
+  .object({
+    // Table name to apply override to
+    tableName: z.string().meta({
+      description:
+        "The entity set name (table occurrence name) this override applies to",
+    }),
+    // Exclude entire table from generation
+    exclude: z.boolean().optional().meta({
+      description:
+        "If true, this entire table will be excluded from generation",
+    }),
+    // Override the generated TypeScript variable name
+    // (original entity set name is still used for the path)
+    variableName: z.string().optional().meta({
+      description:
+        "Override the generated TypeScript variable name. The original entity set name is still used for the OData path.",
+    }),
+    // Field-specific overrides as an array
+    fields: z.array(fieldOverride).optional().meta({
+      description: "Field-specific overrides as an array",
+    }),
+  })
+  .optional();
+
 const typegenConfigSingleBase = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("fmdapi"),
@@ -137,6 +193,10 @@ const typegenConfigSingleBase = z.discriminatedUnion("type", [
       description:
         "If false, the path will not be cleared before the new files are written. Only the `client` and `generated` directories are cleared to allow for potential overrides to be kept.",
     }),
+    tables: z.array(tableOverride).optional().meta({
+      description:
+        "Table-specific overrides as an array. Allows excluding tables/fields, renaming variables, and overriding field types.",
+    }),
   }),
 ]);