@izumisy-tailor/tailor-data-viewer 0.1.21 → 0.1.23

package/src/generator/metadata-generator.ts

@@ -17,56 +17,84 @@ export type FieldType =
  * Metadata for a single field
  */
 export interface FieldMetadata {
-  name: string;
-  type: FieldType;
-  required: boolean;
-  enumValues?: readonly string[];
-  arrayItemType?: FieldType;
-  description?: string;
+  readonly name: string;
+  readonly type: FieldType;
+  readonly required: boolean;
+  readonly enumValues?: readonly string[];
+  readonly arrayItemType?: FieldType;
+  readonly description?: string;
   /** manyToOne relation info (if this field is a foreign key) */
-  relation?: {
+  readonly relation?: {
     /** GraphQL field name for the related object (e.g., "task") */
-    fieldName: string;
+    readonly fieldName: string;
     /** Target table name in camelCase (e.g., "task") */
-    targetTable: string;
+    readonly targetTable: string;
   };
 }
 
 /**
- * Metadata for a relation
+ * Base properties shared by all relation types
  */
-export interface RelationMetadata {
-  /** GraphQL field name (e.g., "task" for manyToOne, "taskAssignments" for oneToMany) */
-  fieldName: string;
+interface RelationMetadataBase {
+  /** GraphQL field name (e.g., "task" for manyToOne/oneToOne, "taskAssignments" for oneToMany) */
+  readonly fieldName: string;
   /** Target table name in camelCase (e.g., "task", "taskAssignment") */
-  targetTable: string;
-  /** Relation type */
-  relationType: "manyToOne" | "oneToMany";
-  /** For manyToOne: the FK field name (e.g., "taskId"). For oneToMany: the FK field on the child table */
-  foreignKeyField: string;
-  /** For manyToOne: the backward field name on the target type (used to generate oneToMany relation) */
-  backwardFieldName?: string;
-  /** True if this is a oneToOne relation (no inverse oneToMany should be generated) */
-  isOneToOne?: boolean;
+  readonly targetTable: string;
+  /** The FK field name (e.g., "taskId") */
+  readonly foreignKeyField: string;
+}
+
+/**
+ * ManyToOne relation: this table has a FK pointing to another table
+ * Generates an inverse oneToMany relation on the target table
+ */
+export interface ManyToOneRelation extends RelationMetadataBase {
+  readonly relationType: "manyToOne";
+  /** The backward field name on the target type (used to generate oneToMany relation) */
+  readonly backwardFieldName?: string;
+}
+
+/**
+ * OneToOne relation: this table has a FK pointing to another table (1:1)
+ * Does NOT generate an inverse oneToMany relation
+ */
+export interface OneToOneRelation extends RelationMetadataBase {
+  readonly relationType: "oneToOne";
+}
+
+/**
+ * OneToMany relation: another table has a FK pointing to this table
+ * Generated automatically from manyToOne relations
+ */
+export interface OneToManyRelation extends RelationMetadataBase {
+  readonly relationType: "oneToMany";
 }
 
+/**
+ * Metadata for a relation (discriminated union)
+ */
+export type RelationMetadata =
+  | ManyToOneRelation
+  | OneToOneRelation
+  | OneToManyRelation;
+
 /**
  * Metadata for a single table
  */
 export interface TableMetadata {
-  name: string;
-  pluralForm: string;
-  description?: string;
-  readAllowedRoles: string[];
-  fields: FieldMetadata[];
-  /** Relations (manyToOne and oneToMany) */
-  relations?: RelationMetadata[];
+  readonly name: string;
+  readonly pluralForm: string;
+  readonly description?: string;
+  readonly readAllowedRoles: readonly string[];
+  readonly fields: readonly FieldMetadata[];
+  /** Relations (manyToOne, oneToOne, and oneToMany) */
+  readonly relations?: readonly RelationMetadata[];
 }
 
 /**
  * Map of all tables
  */
-export type TableMetadataMap = Record<string, TableMetadata>;
+export type TableMetadataMap = { readonly [key: string]: TableMetadata };
 
 /**
  * Expanded relation fields configuration
@@ -304,25 +332,6 @@ export function dataViewerMetadataGenerator(
           config.array,
         );
 
-        const fieldMetadata: FieldMetadata = {
-          name: fieldName,
-          type: fieldType,
-          required: config.required ?? false,
-          description: config.description,
-        };
-
-        // Add enum values if present
-        if (config.allowedValues && config.allowedValues.length > 0) {
-          fieldMetadata.enumValues = config.allowedValues.map((v) =>
-            typeof v === "string" ? v : v.value,
-          );
-        }
-
-        // Add array item type if it's an array field
-        if (arrayItemType) {
-          fieldMetadata.arrayItemType = arrayItemType;
-        }
-
         // Extract manyToOne relation info from rawRelation
         // Include: manyToOne, n-1, oneToOne, 1-1 (all are treated as manyToOne for data view purposes)
         const rawRelation = config.rawRelation;
@@ -338,28 +347,56 @@ export function dataViewerMetadataGenerator(
         const isOneToOne =
           rawRelation?.type === "oneToOne" || rawRelation?.type === "1-1";
 
+        // Build relation info for field if applicable
+        let fieldRelation: FieldMetadata["relation"] | undefined;
         if (isManyToOneRelation && rawRelation.toward) {
           const targetTableName = toCamelCase(rawRelation.toward.type);
           const relationFieldName =
             rawRelation.toward.as ?? toCamelCase(rawRelation.toward.type);
 
-          // Add relation info to the field
-          fieldMetadata.relation = {
+          fieldRelation = {
             fieldName: relationFieldName,
             targetTable: targetTableName,
           };
 
-          // Add to relations array (include backward field name for oneToMany generation)
-          relations.push({
-            fieldName: relationFieldName,
-            targetTable: targetTableName,
-            relationType: "manyToOne",
-            foreignKeyField: fieldName,
-            backwardFieldName: rawRelation.backward,
-            isOneToOne,
-          });
+          // Add to relations array
+          if (isOneToOne) {
+            relations.push({
+              fieldName: relationFieldName,
+              targetTable: targetTableName,
+              relationType: "oneToOne",
+              foreignKeyField: fieldName,
+            });
+          } else {
+            relations.push({
+              fieldName: relationFieldName,
+              targetTable: targetTableName,
+              relationType: "manyToOne",
+              foreignKeyField: fieldName,
+              backwardFieldName: rawRelation.backward,
+            });
+          }
         }
 
+        // Build enum values if present
+        const enumValues =
+          config.allowedValues && config.allowedValues.length > 0
+            ? config.allowedValues.map((v) =>
+                typeof v === "string" ? v : v.value,
+              )
+            : undefined;
+
+        // Create field metadata with all properties at once
+        const fieldMetadata: FieldMetadata = {
+          name: fieldName,
+          type: fieldType,
+          required: config.required ?? false,
+          ...(config.description && { description: config.description }),
+          ...(enumValues && { enumValues }),
+          ...(arrayItemType && { arrayItemType }),
+          ...(fieldRelation && { relation: fieldRelation }),
+        };
+
         fields.push(fieldMetadata);
       }
 
@@ -406,13 +443,9 @@ export function dataViewerMetadataGenerator(
       // Second pass: Add oneToMany relations by inverting manyToOne relations
       for (const table of allTables) {
         for (const relation of table.relations) {
+          // Only manyToOne relations generate inverse oneToMany
+          // oneToOne relations don't have a oneToMany inverse
           if (relation.relationType === "manyToOne") {
-            // Skip oneToOne relations - they don't have a oneToMany inverse
-            // (GraphQL generates a single object field, not a connection)
-            if (relation.isOneToOne) {
-              continue;
-            }
-
             // Find the target table and add the inverse oneToMany relation
             const targetTable = tableByOriginalName.get(
               // Convert camelCase back to PascalCase for lookup
@@ -442,7 +475,7 @@ export function dataViewerMetadataGenerator(
       }
 
       // Build the metadata map (excluding originalName and backwardFieldName from output)
-      const metadataMap: TableMetadataMap = {};
+      const metadataMap: Record<string, TableMetadata> = {};
       for (const table of allTables) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { originalName, ...tableWithoutOriginalName } = table;