@izumisy-tailor/tailor-data-viewer 0.1.9 → 0.1.11

package/README.md

@@ -98,20 +98,6 @@ function App() {
 
 For store options, see [Saved View Store](./docs/saved-view-store.md).
 
-### Using Individual Components
-
-```tsx
-import {
-  DataTable,
-  TableSelector,
-  ColumnSelector,
-  Pagination,
-  SearchFilterForm,
-  useTableData,
-  useColumnState,
-} from "@izumisy-tailor/tailor-data-viewer/component";
-```
-
 ### Generating Table Metadata
 
 This library includes a custom generator for [Tailor Platform SDK](https://www.npmjs.com/package/@tailor-platform/sdk) that automatically generates table metadata from your TailorDB schema.
@@ -128,10 +114,12 @@ npm install @izumisy-tailor/tailor-data-viewer
 
 ```typescript
 import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
-import tableMetadataGenerator from "@izumisy-tailor/tailor-data-viewer/generator";
+import { dataViewerMetadataGenerator } from "@izumisy-tailor/tailor-data-viewer/generator";
 
 export const generators = defineGenerators(
-  tableMetadataGenerator,
+  dataViewerMetadataGenerator({
+    distPath: "src/generated/data-viewer-metadata.generated.ts",
+  }),
   // ... other generators
 );
 
@@ -147,7 +135,7 @@ export default defineConfig({
 tailor-sdk generate
 ```
 
-This will generate a `src/generated/table-metadata.ts` file containing type-safe metadata for all your TailorDB types, including fields, relations, and role-based access control settings.
+This will generate a metadata file at the specified `distPath` containing type-safe metadata for all your TailorDB types, including fields, relations, and role-based access control settings.
 
 ## API Reference
 

package/dist/generator/index.d.mts

@@ -148,7 +148,43 @@ interface GeneratorResult {
   errors?: string[];
 }
 /**
- * Custom generator that extracts table metadata for Data View
+ * Options for the data viewer metadata generator
+ */
+interface DataViewerMetadataGeneratorOptions {
+  /**
+   * Output file path relative to project root
+   * @default "data-viewer-metadata.generated.ts"
+   */
+  distPath?: string;
+}
+/**
+ * Creates a custom generator that extracts table metadata for Data View
+ */
+declare function dataViewerMetadataGenerator(options?: DataViewerMetadataGeneratorOptions): {
+  id: string;
+  description: string;
+  dependencies: ("tailordb" | "resolver" | "executor")[];
+  processType({
+    type
+  }: {
+    type: ParsedTailorDBType;
+  }): ProcessedTable;
+  processResolver(): null;
+  processExecutor(): null;
+  processTailorDBNamespace({
+    types
+  }: {
+    types: Record<string, ProcessedTable>;
+  }): ProcessedTable[];
+  aggregate({
+    input
+  }: {
+    input: GeneratorInput;
+  }): GeneratorResult;
+};
+/**
+ * Default table metadata generator instance
+ * @deprecated Use `dataViewerMetadataGenerator()` instead for custom output path
  */
 declare const tableMetadataGenerator: {
   id: string;
@@ -173,4 +209,4 @@ declare const tableMetadataGenerator: {
   }): GeneratorResult;
 };
 //#endregion
-export { ExpandedRelationFields, FieldMetadata, FieldType, RelationMetadata, TableMetadata, TableMetadataMap, tableMetadataGenerator as default, tableMetadataGenerator };
+export { DataViewerMetadataGeneratorOptions, ExpandedRelationFields, FieldMetadata, FieldType, RelationMetadata, TableMetadata, TableMetadataMap, dataViewerMetadataGenerator, tableMetadataGenerator as default, tableMetadataGenerator };

package/dist/generator/index.mjs

@@ -48,92 +48,94 @@ function extractReadAllowedRoles(gqlPermission) {
 	return Array.from(roles);
 }
 /**
-* Custom generator that extracts table metadata for Data View
+* Creates a custom generator that extracts table metadata for Data View
 */
-const tableMetadataGenerator = {
-	id: "table-metadata",
-	description: "Generates table metadata for Data View including field definitions and read permissions",
-	dependencies: ["tailordb"],
-	processType({ type }) {
-		const fields = [];
-		const relations = [];
-		for (const [fieldName, field] of Object.entries(type.fields)) {
-			const config = field.config;
-			const { type: fieldType, arrayItemType } = mapFieldType(config.type, config.array);
-			const fieldMetadata = {
-				name: fieldName,
-				type: fieldType,
-				required: config.required ?? false,
-				description: config.description
-			};
-			if (config.allowedValues && config.allowedValues.length > 0) fieldMetadata.enumValues = config.allowedValues.map((v) => typeof v === "string" ? v : v.value);
-			if (arrayItemType) fieldMetadata.arrayItemType = arrayItemType;
-			const rawRelation = config.rawRelation;
-			const isManyToOneRelation = rawRelation && (rawRelation.type === "manyToOne" || rawRelation.type === "n-1" || rawRelation.type === "oneToOne" || rawRelation.type === "1-1") && rawRelation.toward;
-			const isOneToOne = rawRelation?.type === "oneToOne" || rawRelation?.type === "1-1";
-			if (isManyToOneRelation && rawRelation.toward) {
-				const targetTableName = toCamelCase(rawRelation.toward.type);
-				const relationFieldName = rawRelation.toward.as ?? toCamelCase(rawRelation.toward.type);
-				fieldMetadata.relation = {
-					fieldName: relationFieldName,
-					targetTable: targetTableName
+function dataViewerMetadataGenerator(options = {}) {
+	const { distPath = "data-viewer-metadata.generated.ts" } = options;
+	return {
+		id: "table-metadata",
+		description: "Generates table metadata for Data View including field definitions and read permissions",
+		dependencies: ["tailordb"],
+		processType({ type }) {
+			const fields = [];
+			const relations = [];
+			for (const [fieldName, field] of Object.entries(type.fields)) {
+				const config = field.config;
+				const { type: fieldType, arrayItemType } = mapFieldType(config.type, config.array);
+				const fieldMetadata = {
+					name: fieldName,
+					type: fieldType,
+					required: config.required ?? false,
+					description: config.description
 				};
-				relations.push({
-					fieldName: relationFieldName,
-					targetTable: targetTableName,
-					relationType: "manyToOne",
-					foreignKeyField: fieldName,
-					backwardFieldName: rawRelation.backward,
-					isOneToOne
-				});
+				if (config.allowedValues && config.allowedValues.length > 0) fieldMetadata.enumValues = config.allowedValues.map((v) => typeof v === "string" ? v : v.value);
+				if (arrayItemType) fieldMetadata.arrayItemType = arrayItemType;
+				const rawRelation = config.rawRelation;
+				const isManyToOneRelation = rawRelation && (rawRelation.type === "manyToOne" || rawRelation.type === "n-1" || rawRelation.type === "oneToOne" || rawRelation.type === "1-1") && rawRelation.toward;
+				const isOneToOne = rawRelation?.type === "oneToOne" || rawRelation?.type === "1-1";
+				if (isManyToOneRelation && rawRelation.toward) {
+					const targetTableName = toCamelCase(rawRelation.toward.type);
+					const relationFieldName = rawRelation.toward.as ?? toCamelCase(rawRelation.toward.type);
+					fieldMetadata.relation = {
+						fieldName: relationFieldName,
+						targetTable: targetTableName
+					};
+					relations.push({
+						fieldName: relationFieldName,
+						targetTable: targetTableName,
+						relationType: "manyToOne",
+						foreignKeyField: fieldName,
+						backwardFieldName: rawRelation.backward,
+						isOneToOne
+					});
+				}
+				fields.push(fieldMetadata);
 			}
-			fields.push(fieldMetadata);
-		}
-		const readAllowedRoles = extractReadAllowedRoles(type.permissions.gql);
-		return {
-			name: toCamelCase(type.name),
-			pluralForm: toCamelCase(type.pluralForm),
-			originalName: type.name,
-			description: type.description,
-			readAllowedRoles,
-			fields,
-			relations
-		};
-	},
-	processResolver() {
-		return null;
-	},
-	processExecutor() {
-		return null;
-	},
-	processTailorDBNamespace({ types }) {
-		return Object.values(types);
-	},
-	aggregate({ input }) {
-		const allTables = input.tailordb.flatMap((ns) => ns.types);
-		const tableByOriginalName = /* @__PURE__ */ new Map();
-		for (const table of allTables) tableByOriginalName.set(table.originalName, table);
-		for (const table of allTables) for (const relation of table.relations) if (relation.relationType === "manyToOne") {
-			if (relation.isOneToOne) continue;
-			const targetTable = tableByOriginalName.get(relation.targetTable.charAt(0).toUpperCase() + relation.targetTable.slice(1));
-			if (targetTable) {
-				const oneToManyFieldName = relation.backwardFieldName ?? table.pluralForm;
-				if (!targetTable.relations.some((r) => r.relationType === "oneToMany" && r.fieldName === oneToManyFieldName)) targetTable.relations.push({
-					fieldName: oneToManyFieldName,
-					targetTable: table.name,
-					relationType: "oneToMany",
-					foreignKeyField: relation.foreignKeyField
-				});
+			const readAllowedRoles = extractReadAllowedRoles(type.permissions.gql);
+			return {
+				name: toCamelCase(type.name),
+				pluralForm: toCamelCase(type.pluralForm),
+				originalName: type.name,
+				description: type.description,
+				readAllowedRoles,
+				fields,
+				relations
+			};
+		},
+		processResolver() {
+			return null;
+		},
+		processExecutor() {
+			return null;
+		},
+		processTailorDBNamespace({ types }) {
+			return Object.values(types);
+		},
+		aggregate({ input }) {
+			const allTables = input.tailordb.flatMap((ns) => ns.types);
+			const tableByOriginalName = /* @__PURE__ */ new Map();
+			for (const table of allTables) tableByOriginalName.set(table.originalName, table);
+			for (const table of allTables) for (const relation of table.relations) if (relation.relationType === "manyToOne") {
+				if (relation.isOneToOne) continue;
+				const targetTable = tableByOriginalName.get(relation.targetTable.charAt(0).toUpperCase() + relation.targetTable.slice(1));
+				if (targetTable) {
+					const oneToManyFieldName = relation.backwardFieldName ?? table.pluralForm;
+					if (!targetTable.relations.some((r) => r.relationType === "oneToMany" && r.fieldName === oneToManyFieldName)) targetTable.relations.push({
+						fieldName: oneToManyFieldName,
+						targetTable: table.name,
+						relationType: "oneToMany",
+						foreignKeyField: relation.foreignKeyField
+					});
+				}
 			}
-		}
-		const metadataMap = {};
-		for (const table of allTables) {
-			const { originalName, ...tableWithoutOriginalName } = table;
-			metadataMap[table.name] = tableWithoutOriginalName;
-		}
-		return { files: [{
-			path: "src/generated/table-metadata.ts",
-			content: `// This file is auto-generated by table-metadata-generator
+			const metadataMap = {};
+			for (const table of allTables) {
+				const { originalName, ...tableWithoutOriginalName } = table;
+				metadataMap[table.name] = tableWithoutOriginalName;
+			}
+			return { files: [{
+				path: distPath,
+				content: `// This file is auto-generated by table-metadata-generator
 // Do not edit manually
 
 import type {
@@ -152,10 +154,16 @@ export const tableNames = ${JSON.stringify(Object.keys(metadataMap), null, 2)} a
 
 export type TableName = (typeof tableNames)[number];
 `
-		}] };
-	}
-};
+			}] };
+		}
+	};
+}
+/**
+* Default table metadata generator instance
+* @deprecated Use `dataViewerMetadataGenerator()` instead for custom output path
+*/
+const tableMetadataGenerator = dataViewerMetadataGenerator();
 var metadata_generator_default = tableMetadataGenerator;
 
 //#endregion
-export { metadata_generator_default as default, tableMetadataGenerator };
+export { dataViewerMetadataGenerator, metadata_generator_default as default, tableMetadataGenerator };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@izumisy-tailor/tailor-data-viewer",
   "private": false,
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "description": "Flexible data viewer component for Tailor Platform",
   "files": [

package/src/component/data-viewer.tsx

@@ -1,4 +1,4 @@
-import { useState, useCallback } from "react";
+import { useState, useCallback, useEffect, useRef } from "react";
 import { Plus, X } from "lucide-react";
 import { Card, CardContent, CardHeader, CardTitle } from "./ui/card";
 import { Button } from "./ui/button";
@@ -57,27 +57,13 @@ export function DataViewer({
   initialViewId,
 }: DataViewerProps) {
   const allTables = Object.values(tableMetadata);
-  const { getViewById } = useSavedViews();
+  const { getViewById, isLoading } = useSavedViews();
 
-  // Tab management - initialize with saved view if provided
+  // Track if we've already initialized from the saved view
+  const initializedFromViewRef = useRef(false);
+
+  // Tab management - start with empty tab, will apply saved view after loading
   const [tabs, setTabs] = useState<Tab[]>(() => {
-    if (initialViewId) {
-      const view = getViewById(initialViewId);
-      if (view) {
-        const table = tableMetadata[view.tableName];
-        if (table) {
-          return [
-            {
-              id: generateTabId(),
-              label: view.name,
-              table,
-              isLocked: true,
-              initialView: view,
-            },
-          ];
-        }
-      }
-    }
     return [
       {
         id: generateTabId(),
@@ -89,6 +75,31 @@ export function DataViewer({
   });
   const [activeTabId, setActiveTabId] = useState<string>(tabs[0].id);
 
+  // Apply saved view after views are loaded from store
+  useEffect(() => {
+    // Skip if no initialViewId, already initialized, or still loading
+    if (!initialViewId || initializedFromViewRef.current || isLoading) {
+      return;
+    }
+
+    const view = getViewById(initialViewId);
+    if (view) {
+      const table = tableMetadata[view.tableName];
+      if (table) {
+        initializedFromViewRef.current = true;
+        const newTab: Tab = {
+          id: generateTabId(),
+          label: view.name,
+          table,
+          isLocked: true,
+          initialView: view,
+        };
+        setTabs([newTab]);
+        setActiveTabId(newTab.id);
+      }
+    }
+  }, [initialViewId, isLoading, getViewById, tableMetadata]);
+
   const handleAddTab = useCallback(() => {
     const newTab: Tab = {
       id: generateTabId(),

package/src/component/index.ts

@@ -1,14 +1,4 @@
 export { DataViewer } from "./data-viewer";
 export type { InitialQuery } from "./data-viewer";
-export { DataViewTabContent } from "./data-view-tab-content";
-export { TableSelector } from "./table-selector";
-export { ColumnSelector } from "./column-selector";
-export { DataTable } from "./data-table";
-export { Pagination } from "./pagination";
-export { SearchFilterForm } from "./search-filter";
-export { ViewSave } from "./view-save-load";
-export { useTableData } from "./hooks/use-table-data";
-export { useColumnState } from "./hooks/use-column-state";
 export { useSavedViews, SavedViewProvider } from "./saved-view-context";
 export type { SavedView, SaveViewInput } from "./saved-view-context";
-export type { SearchFilter, SearchFilters } from "./types";

package/src/component/single-record-tab-content.tsx

@@ -346,8 +346,7 @@ export function SingleRecordTabContent({
         }
       }
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [record, tableMetadata.relations]);
+  }, [record, tableMetadata.relations, fetchManyToOneData, fetchRelationData]);
 
   const handleRefresh = () => {
     fetchRecord();

package/src/generator/metadata-generator.ts

@@ -267,174 +267,190 @@ interface GeneratorResult {
 }
 
 /**
- * Custom generator that extracts table metadata for Data View
+ * Options for the data viewer metadata generator
  */
-export const tableMetadataGenerator = {
-  id: "table-metadata",
-  description:
-    "Generates table metadata for Data View including field definitions and read permissions",
-  dependencies: ["tailordb"] as ("tailordb" | "resolver" | "executor")[],
-
-  processType({ type }: { type: ParsedTailorDBType }): ProcessedTable {
-    const fields: FieldMetadata[] = [];
-    const relations: RelationMetadata[] = [];
-
-    // Process each field
-    for (const [fieldName, field] of Object.entries(type.fields)) {
-      const config = field.config;
-
-      const { type: fieldType, arrayItemType } = mapFieldType(
-        config.type,
-        config.array,
-      );
-
-      const fieldMetadata: FieldMetadata = {
-        name: fieldName,
-        type: fieldType,
-        required: config.required ?? false,
-        description: config.description,
-      };
+export interface DataViewerMetadataGeneratorOptions {
+  /**
+   * Output file path relative to project root
+   * @default "data-viewer-metadata.generated.ts"
+   */
+  distPath?: string;
+}
 
-      // Add enum values if present
-      if (config.allowedValues && config.allowedValues.length > 0) {
-        fieldMetadata.enumValues = config.allowedValues.map((v) =>
-          typeof v === "string" ? v : v.value,
+/**
+ * Creates a custom generator that extracts table metadata for Data View
+ */
+export function dataViewerMetadataGenerator(
+  options: DataViewerMetadataGeneratorOptions = {},
+) {
+  const { distPath = "data-viewer-metadata.generated.ts" } = options;
+
+  return {
+    id: "table-metadata",
+    description:
+      "Generates table metadata for Data View including field definitions and read permissions",
+    dependencies: ["tailordb"] as ("tailordb" | "resolver" | "executor")[],
+
+    processType({ type }: { type: ParsedTailorDBType }): ProcessedTable {
+      const fields: FieldMetadata[] = [];
+      const relations: RelationMetadata[] = [];
+
+      // Process each field
+      for (const [fieldName, field] of Object.entries(type.fields)) {
+        const config = field.config;
+
+        const { type: fieldType, arrayItemType } = mapFieldType(
+          config.type,
+          config.array,
         );
-      }
 
-      // 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;
-      const isManyToOneRelation =
-        rawRelation &&
-        (rawRelation.type === "manyToOne" ||
-          rawRelation.type === "n-1" ||
-          rawRelation.type === "oneToOne" ||
-          rawRelation.type === "1-1") &&
-        rawRelation.toward;
-
-      // Check if this is a oneToOne relation (no inverse oneToMany should be generated)
-      const isOneToOne =
-        rawRelation?.type === "oneToOne" || rawRelation?.type === "1-1";
-
-      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 = {
-          fieldName: relationFieldName,
-          targetTable: targetTableName,
+        const fieldMetadata: FieldMetadata = {
+          name: fieldName,
+          type: fieldType,
+          required: config.required ?? false,
+          description: config.description,
         };
 
-        // 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 enum values if present
+        if (config.allowedValues && config.allowedValues.length > 0) {
+          fieldMetadata.enumValues = config.allowedValues.map((v) =>
+            typeof v === "string" ? v : v.value,
+          );
+        }
 
-      fields.push(fieldMetadata);
-    }
+        // Add array item type if it's an array field
+        if (arrayItemType) {
+          fieldMetadata.arrayItemType = arrayItemType;
+        }
 
-    // Extract read allowed roles from gql permission
-    const readAllowedRoles = extractReadAllowedRoles(type.permissions.gql);
-
-    return {
-      name: toCamelCase(type.name),
-      pluralForm: toCamelCase(type.pluralForm),
-      originalName: type.name,
-      description: type.description,
-      readAllowedRoles,
-      fields,
-      relations,
-    };
-  },
-
-  processResolver() {
-    return null;
-  },
-
-  processExecutor() {
-    return null;
-  },
-
-  processTailorDBNamespace({
-    types,
-  }: {
-    types: Record<string, ProcessedTable>;
-  }): ProcessedTable[] {
-    return Object.values(types);
-  },
-
-  aggregate({ input }: { input: GeneratorInput }): GeneratorResult {
-    // Collect all tables from all namespaces
-    const allTables = input.tailordb.flatMap((ns) => ns.types);
-
-    // Build a map of originalName -> table for relation lookup
-    const tableByOriginalName = new Map<string, ProcessedTable>();
-    for (const table of allTables) {
-      tableByOriginalName.set(table.originalName, table);
-    }
+        // 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;
+        const isManyToOneRelation =
+          rawRelation &&
+          (rawRelation.type === "manyToOne" ||
+            rawRelation.type === "n-1" ||
+            rawRelation.type === "oneToOne" ||
+            rawRelation.type === "1-1") &&
+          rawRelation.toward;
+
+        // Check if this is a oneToOne relation (no inverse oneToMany should be generated)
+        const isOneToOne =
+          rawRelation?.type === "oneToOne" || rawRelation?.type === "1-1";
+
+        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 = {
+            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,
+          });
+        }
 
-    // Second pass: Add oneToMany relations by inverting manyToOne relations
-    for (const table of allTables) {
-      for (const relation of table.relations) {
-        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;
-          }
+        fields.push(fieldMetadata);
+      }
 
-          // Find the target table and add the inverse oneToMany relation
-          const targetTable = tableByOriginalName.get(
-            // Convert camelCase back to PascalCase for lookup
-            relation.targetTable.charAt(0).toUpperCase() +
-              relation.targetTable.slice(1),
-          );
-          if (targetTable) {
-            // Use backward field name if specified, otherwise fall back to plural form
-            const oneToManyFieldName =
-              relation.backwardFieldName ?? table.pluralForm;
-            const alreadyExists = targetTable.relations.some(
-              (r) =>
-                r.relationType === "oneToMany" &&
-                r.fieldName === oneToManyFieldName,
+      // Extract read allowed roles from gql permission
+      const readAllowedRoles = extractReadAllowedRoles(type.permissions.gql);
+
+      return {
+        name: toCamelCase(type.name),
+        pluralForm: toCamelCase(type.pluralForm),
+        originalName: type.name,
+        description: type.description,
+        readAllowedRoles,
+        fields,
+        relations,
+      };
+    },
+
+    processResolver() {
+      return null;
+    },
+
+    processExecutor() {
+      return null;
+    },
+
+    processTailorDBNamespace({
+      types,
+    }: {
+      types: Record<string, ProcessedTable>;
+    }): ProcessedTable[] {
+      return Object.values(types);
+    },
+
+    aggregate({ input }: { input: GeneratorInput }): GeneratorResult {
+      // Collect all tables from all namespaces
+      const allTables = input.tailordb.flatMap((ns) => ns.types);
+
+      // Build a map of originalName -> table for relation lookup
+      const tableByOriginalName = new Map<string, ProcessedTable>();
+      for (const table of allTables) {
+        tableByOriginalName.set(table.originalName, table);
+      }
+
+      // Second pass: Add oneToMany relations by inverting manyToOne relations
+      for (const table of allTables) {
+        for (const relation of table.relations) {
+          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
+              relation.targetTable.charAt(0).toUpperCase() +
+                relation.targetTable.slice(1),
             );
-            if (!alreadyExists) {
-              targetTable.relations.push({
-                fieldName: oneToManyFieldName,
-                targetTable: table.name,
-                relationType: "oneToMany",
-                foreignKeyField: relation.foreignKeyField,
-              });
+            if (targetTable) {
+              // Use backward field name if specified, otherwise fall back to plural form
+              const oneToManyFieldName =
+                relation.backwardFieldName ?? table.pluralForm;
+              const alreadyExists = targetTable.relations.some(
+                (r) =>
+                  r.relationType === "oneToMany" &&
+                  r.fieldName === oneToManyFieldName,
+              );
+              if (!alreadyExists) {
+                targetTable.relations.push({
+                  fieldName: oneToManyFieldName,
+                  targetTable: table.name,
+                  relationType: "oneToMany",
+                  foreignKeyField: relation.foreignKeyField,
+                });
+              }
             }
           }
         }
       }
-    }
 
-    // Build the metadata map (excluding originalName and backwardFieldName from output)
-    const metadataMap: TableMetadataMap = {};
-    for (const table of allTables) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { originalName, ...tableWithoutOriginalName } = table;
-      metadataMap[table.name] = tableWithoutOriginalName;
-    }
+      // Build the metadata map (excluding originalName and backwardFieldName from output)
+      const metadataMap: TableMetadataMap = {};
+      for (const table of allTables) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { originalName, ...tableWithoutOriginalName } = table;
+        metadataMap[table.name] = tableWithoutOriginalName;
+      }
 
-    // Generate the TypeScript content
-    const content = `// This file is auto-generated by table-metadata-generator
+      // Generate the TypeScript content
+      const content = `// This file is auto-generated by table-metadata-generator
 // Do not edit manually
 
 import type {
@@ -454,15 +470,22 @@ export const tableNames = ${JSON.stringify(Object.keys(metadataMap), null, 2)} a
 export type TableName = (typeof tableNames)[number];
 `;
 
-    return {
-      files: [
-        {
-          path: "src/generated/table-metadata.ts",
-          content,
-        },
-      ],
-    };
-  },
-};
+      return {
+        files: [
+          {
+            path: distPath,
+            content,
+          },
+        ],
+      };
+    },
+  };
+}
+
+/**
+ * Default table metadata generator instance
+ * @deprecated Use `dataViewerMetadataGenerator()` instead for custom output path
+ */
+export const tableMetadataGenerator = dataViewerMetadataGenerator();
 
 export default tableMetadataGenerator;