@izumisy-tailor/tailor-data-viewer 0.1.0

package/src/utils/query-builder.ts

@@ -0,0 +1,190 @@
+import type {
+  TableMetadata,
+  FieldMetadata,
+  RelationMetadata,
+} from "../types/table-metadata";
+
+/**
+ * Convert camelCase to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Relation total info to fetch (for oneToMany relations)
+ */
+export interface RelationTotalInfo {
+  /** The oneToMany relation metadata */
+  relation: RelationMetadata;
+  /** The plural form of the target table (e.g., "taskAssignments") */
+  targetPluralForm: string;
+}
+
+/**
+ * Expanded relation info for manyToOne relations to be fetched inline
+ */
+export interface ExpandedRelationInfo {
+  /** The manyToOne relation metadata */
+  relation: RelationMetadata;
+  /** Selected fields from the target table */
+  selectedFields: string[];
+}
+
+/**
+ * Options for building a list query
+ */
+export interface QueryOptions {
+  tableName: string;
+  pluralForm: string;
+  selectedFields: string[];
+  orderBy?: { field: string; direction: "Asc" | "Desc" };
+  first?: number;
+  after?: string;
+  /** oneToMany relations to fetch total count for */
+  oneToManyRelationTotals?: RelationTotalInfo[];
+  /** manyToOne relations to fetch inline with selected fields */
+  expandedManyToOneRelations?: ExpandedRelationInfo[];
+}
+
+/**
+ * Build a GraphQL list query dynamically based on table metadata
+ */
+export function buildListQuery(options: QueryOptions): string {
+  const {
+    tableName,
+    pluralForm,
+    selectedFields,
+    orderBy,
+    first,
+    after,
+    oneToManyRelationTotals,
+    expandedManyToOneRelations,
+  } = options;
+
+  // GraphQL type names need PascalCase
+  const typeName = toPascalCase(tableName);
+
+  // Build order clause if specified
+  const orderArg = orderBy
+    ? `, order: [{ field: ${typeName}OrderFields.${orderBy.field}, direction: OrderDirection.${orderBy.direction} }]`
+    : "";
+
+  // Build pagination arguments
+  const firstArg = first !== undefined ? `, first: ${first}` : "";
+  const afterArg = after !== undefined ? `, after: "${after}"` : "";
+
+  // Build oneToMany relation total fields (fetching only total for display before expansion)
+  // These are nested connection queries that get total count for each parent record
+  const relationTotalFields =
+    oneToManyRelationTotals
+      ?.map((info) => {
+        return `${info.relation.fieldName}(first: 0) {
+              total
+            }`;
+      })
+      .join("\n            ") ?? "";
+
+  // Build expanded manyToOne relation fields (inline object fetching)
+  const expandedRelationFields =
+    expandedManyToOneRelations
+      ?.filter((info) => info.selectedFields.length > 0)
+      .map((info) => {
+        const nestedFields = info.selectedFields.join("\n              ");
+        return `${info.relation.fieldName} {
+              ${nestedFields}
+            }`;
+      })
+      .join("\n            ") ?? "";
+
+  // Format fields with proper indentation
+  const fieldsStr = selectedFields.join("\n            ");
+  let allFieldsStr = fieldsStr;
+  if (relationTotalFields) {
+    allFieldsStr = `${allFieldsStr}\n            ${relationTotalFields}`;
+  }
+  if (expandedRelationFields) {
+    allFieldsStr = `${allFieldsStr}\n            ${expandedRelationFields}`;
+  }
+
+  return `
+    query ${typeName}List($query: ${typeName}QueryInput) {
+      ${pluralForm}(query: $query${orderArg}${firstArg}${afterArg}) {
+        edges {
+          node {
+            ${allFieldsStr}
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `.trim();
+}
+
+/**
+ * Get default selected fields for a table
+ * Excludes nested, array, and id fields by default
+ */
+export function getDefaultSelectedFields(table: TableMetadata): string[] {
+  return table.fields
+    .filter(
+      (field) =>
+        field.type !== "nested" &&
+        field.type !== "array" &&
+        // Exclude id fields (both 'id' and relation ids like 'taskId')
+        field.name !== "id" &&
+        !field.name.endsWith("Id"),
+    )
+    .map((field) => field.name);
+}
+
+/**
+ * Get all selectable fields (excluding nested types)
+ */
+export function getSelectableFields(table: TableMetadata): FieldMetadata[] {
+  return table.fields.filter((field) => field.type !== "nested");
+}
+
+/**
+ * Format a value based on its field type for display
+ */
+export function formatFieldValue(value: unknown, field: FieldMetadata): string {
+  if (value === null || value === undefined) {
+    return "-";
+  }
+
+  // Helper to safely convert unknown to string
+  const toStr = (v: unknown): string =>
+    typeof v === "string"
+      ? v
+      : typeof v === "number" || typeof v === "boolean"
+        ? v.toString()
+        : JSON.stringify(v);
+
+  switch (field.type) {
+    case "datetime":
+      return new Date(toStr(value)).toLocaleString("ja-JP");
+    case "date":
+      return new Date(toStr(value)).toLocaleDateString("ja-JP");
+    case "time":
+      return toStr(value);
+    case "boolean":
+      return value ? "はい" : "いいえ";
+    case "number":
+      return typeof value === "number"
+        ? value.toLocaleString("ja-JP")
+        : toStr(value);
+    case "array":
+      return Array.isArray(value)
+        ? value.map((v) => toStr(v)).join(", ")
+        : toStr(value);
+    case "uuid":
+      // Show truncated UUID for better readability
+      return toStr(value).substring(0, 8) + "...";
+    default:
+      return toStr(value);
+  }
+}