Merge branch 'development' into enhancement/DX-3404

Author: naman-contentstack

.talismanrc

@@ -3,7 +3,7 @@ fileignoreconfig:
     ignore_detectors:
       - filecontent
   - filename: package-lock.json
-    checksum: 935e3c4e56b12c01608ff169a0d025acee6a01e7464fa500f50c1c202c8af08b
+    checksum: 8c3e07947c069ab2ea4e523b18157b600707eb43fe06612a05bcb23e55fe5fc6
   - filename: .husky/pre-commit
     checksum: 5baabd7d2c391648163f9371f0e5e9484f8fb90fa2284cfc378732ec3192c193
   - filename: src/graphqlTS/index.ts
@@ -14,4 +14,8 @@ fileignoreconfig:
     checksum: a7febf9673f6bb759da48c1984cffbf813861a9e2695f1416741ca17aeeb71d7
   - filename: src/generateTS/factory.ts
     checksum: d6dd1ebc15493f9ed5e748f93d2f7c11b8dead5e0985482677270d450b94d270
+  - filename: tests/integration/graphqlTS/graphqlTS.test.ts
+    checksum: 7ffa82084fd0fc2f5ec9c8e8124cdf1bce08c7f75c5be2ede2eb5cd506812db1
+  - filename: tests/integration/generateTS/generateTS.test.ts
+    checksum: 7c1bc7d659ee2f9f52bf644b9e512984f89e0ff6aa4288b6e30b2c899bf80123
 version: "1.0"

package-lock.json

@@ -18,6 +18,7 @@ export type TSGenOptions = {
   };
   systemFields?: boolean;
   isEditableTags?: boolean;
+  includeReferencedEntry?: boolean;
 };
 
 export type TSGenResult = {
@@ -74,6 +75,7 @@ const defaultOptions: TSGenOptions = {
   },
   systemFields: false,
   isEditableTags: false,
+  includeReferencedEntry: false,
 };
 
 export default function (userOptions: TSGenOptions) {
@@ -534,6 +536,33 @@ export default function (userOptions: TSGenOptions) {
     return name_type(field.reference_to);
   }
 
+  function buildReferenceArrayType(references: string[], options: any): string {
+    // If no valid references remain, return a more specific fallback type
+    if (references.length === 0) {
+      return "Record<string, unknown>[]";
+    }
+
+    // Handle reference types with or without ReferencedEntry interface
+    if (options.includeReferencedEntry) {
+      const referencedEntryType = `${options.naming?.prefix || ""}ReferencedEntry`;
+
+      const wrapWithReferencedEntry = (refType: string) =>
+        `(${refType} | ${referencedEntryType})`;
+
+      const types =
+        references.length === 1
+          ? wrapWithReferencedEntry(references[0])
+          : references.map(wrapWithReferencedEntry).join(" | ");
+
+      return `${types}[]`;
+    }
+
+    const baseType =
+      references.length === 1 ? references[0] : references.join(" | ");
+
+    return `${baseType}[]`;
+  }
+
   function type_reference(field: ContentstackTypes.Field) {
     const references: string[] = [];
 
@@ -561,25 +590,7 @@ export default function (userOptions: TSGenOptions) {
       }
     }
 
-    // If no valid references remain, return a more specific fallback type
-    if (references.length === 0) {
-      return "Record<string, unknown>[]";
-    }
-
-    // Use the ReferencedEntry interface from builtins
-    const referencedEntryType = `${options.naming?.prefix || ""}ReferencedEntry`;
-
-    // If there's only one reference type, create a simple union
-    if (references.length === 1) {
-      return `(${references[0]} | ${referencedEntryType})[]`;
-    }
-
-    // If there are multiple reference types, create separate unions for each
-    const unionTypes = references.map((refType) => {
-      return `(${refType} | ${referencedEntryType})`;
-    });
-
-    return `${unionTypes.join(" | ")}[]`;
+    return buildReferenceArrayType(references, options);
   }
 
   return function (

src/generateTS/factory.ts

@@ -24,6 +24,7 @@ export const generateTS = async ({
   includeDocumentation,
   systemFields,
   isEditableTags,
+  includeReferencedEntry,
   host,
 }: GenerateTS) => {
   try {
@@ -84,6 +85,7 @@ export const generateTS = async ({
           includeDocumentation,
           systemFields,
           isEditableTags,
+          includeReferencedEntry,
         });
         return generatedTS;
       }
@@ -134,6 +136,7 @@ export const generateTSFromContentTypes = async ({
   includeDocumentation = true,
   systemFields = false,
   isEditableTags = false,
+  includeReferencedEntry = false,
 }: GenerateTSFromContentTypes) => {
   try {
     const docgen: DocumentationGenerator = includeDocumentation
@@ -147,6 +150,7 @@ export const generateTSFromContentTypes = async ({
       naming: { prefix },
       systemFields,
       isEditableTags,
+      includeReferencedEntry,
     });
     for (const contentType of contentTypes) {
       const tsgenResult = tsgen(contentType);
@@ -173,7 +177,8 @@ export const generateTSFromContentTypes = async ({
           prefix,
           systemFields,
           isEditableTags,
-          hasJsonField
+          hasJsonField,
+          includeReferencedEntry
         ).join("\n\n"),
         [...globalFields].join("\n\n"),
         definitions.join("\n\n"),

src/generateTS/index.ts

@@ -4,24 +4,36 @@ export const defaultInterfaces = (
   prefix = "",
   systemFields = false,
   isEditableTags = false,
-  hasJsonRte?: boolean
+  hasJsonRte?: boolean,
+  includeReferencedEntry = false
 ) => {
   const defaultInterfaces = [
     `type BuildTuple<T, N extends number, R extends T[] = []> =
     R['length'] extends N ? R : BuildTuple<T, N, [...R, T]>`,
     `type TuplePrefixes<T extends any[]> = 
     T extends [any, ...infer Rest] ? T | TuplePrefixes<Rest extends any[] ? Rest : []> : []`,
     `type MaxTuple<T, N extends number> = TuplePrefixes<BuildTuple<T, N>>`,
-    `export interface ${prefix}ReferencedEntry {
+  ];
+
+  // Conditionally include ReferencedEntry interface
+  if (includeReferencedEntry) {
+    defaultInterfaces.push(
+      `export interface ${prefix}ReferencedEntry {
             uid: string;
             _content_type_uid: string;
-        }`,
+        }`
+    );
+  }
+
+  defaultInterfaces.push(
     `export interface ${prefix}PublishDetails {
             environment: string;
             locale: string;
             time: string;
             user: string;
-        }`,
+        }`
+  );
+  defaultInterfaces.push(
     `export interface ${prefix}File { 
               uid: string;
               created_at: string;
@@ -45,19 +57,25 @@ export const defaultInterfaces = (
                 width: number;
             }
               publish_details: ${prefix}PublishDetails;
-          }`,
+          }`
+  );
+  defaultInterfaces.push(
     `export interface ${prefix}Link { 
               title: string;
               href: string;
-          }`,
+          }`
+  );
+  defaultInterfaces.push(
     `export interface ${prefix}Taxonomy { 
             taxonomy_uid: string;
             max_terms?: number;
             mandatory: boolean;
             non_localizable: boolean;
-        }`,
-    `export type ${prefix}TaxonomyEntry = ${prefix}Taxonomy & { term_uid: string }`,
-  ];
+        }`
+  );
+  defaultInterfaces.push(
+    `export type ${prefix}TaxonomyEntry = ${prefix}Taxonomy & { term_uid: string }`
+  );
   if (hasJsonRte) {
     defaultInterfaces.push(
       `export interface JSONRTENode {

src/generateTS/stack/builtins.ts

@@ -24,6 +24,7 @@ export interface GenerateTSBase extends StackConnectionConfig {
   includeDocumentation?: boolean;
   systemFields?: boolean;
   isEditableTags?: boolean;
+  includeReferencedEntry?: boolean;
 }
 
 export type GenerateTS = GenerateTSBase;
@@ -38,4 +39,5 @@ export interface GenerateTSFromContentTypes {
   includeDocumentation?: boolean;
   systemFields?: boolean;
   isEditableTags?: boolean;
+  includeReferencedEntry?: boolean;
 }

src/types/index.ts

@@ -111,12 +111,58 @@ describe("generateTS function", () => {
     });
 
     expect(generatedTS).toEqual(expect.stringContaining("interface")); // Check for Output is not undefined
-    expect(generatedTS).toMatch(/export interface CSLPAttribute/); // Check for CSLP attribute interface is created
-    expect(generatedTS).toMatch(/export type CSLPFieldMapping/); // Check for CSLP field mapping type is created
+    expect(generatedTS).toMatch(/Dishes/); // Check for whether typeDef of Content type is included
+    expect(generatedTS).toMatch(/export interface CSLPAttribute/); // Check for whether CSLP attribute interface is created
+    expect(generatedTS).toMatch(/export type CSLPFieldMapping/); // Check for whether CSLP field mapping type is created
     expect(generatedTS).toMatch(/\$\?\:/); // Check for editable field mappings with $ property
     expect(generatedTS).toMatch(/\?\: CSLPFieldMapping/); // Check for individual field CSLP mappings
     expect(generatedTS).toMatch(/\/\*\*.*\*\/\n\s*(export)/); // Check for Documentation is generated
   });
+
+  it("generates type definitions with ReferencedEntry enabled", async () => {
+    const token = process.env.TOKEN as unknown as any;
+    const apiKey = process.env.APIKEY as unknown as any;
+    const environment = process.env.ENVIRONMENT as unknown as any;
+    const region = process.env.REGION as unknown as any;
+    const tokenType = process.env.TOKENTYPE as unknown as any;
+    const includeReferencedEntry = true;
+
+    const generatedTS = await generateTS({
+      token,
+      apiKey,
+      environment,
+      region,
+      tokenType,
+      includeReferencedEntry,
+    });
+
+    expect(generatedTS).toEqual(expect.stringContaining("interface")); // Check for Output is not undefined
+    expect(generatedTS).toEqual(expect.stringContaining("Dishes")); // Check for whether typeDef of Content type is included
+    expect(generatedTS).toMatch(/ReferencedEntry/); // Check that ReferencedEntry interface is included
+    expect(generatedTS).toMatch(/\/\*\*.*\*\/\n\s*(export)/); // Check for Documentation is generated
+  });
+
+  it("generates type definitions without ReferencedEntry (default)", async () => {
+    const token = process.env.TOKEN as unknown as any;
+    const apiKey = process.env.APIKEY as unknown as any;
+    const environment = process.env.ENVIRONMENT as unknown as any;
+    const region = process.env.REGION as unknown as any;
+    const tokenType = process.env.TOKENTYPE as unknown as any;
+    // Don't pass includeReferencedEntry, should default to false
+
+    const generatedTS = await generateTS({
+      token,
+      apiKey,
+      environment,
+      region,
+      tokenType,
+    });
+
+    expect(generatedTS).toEqual(expect.stringContaining("interface")); // Check for Output is not undefined
+    expect(generatedTS).toEqual(expect.stringContaining("Dishes")); // Check for whether typeDef of Content type is included
+    expect(generatedTS).not.toMatch(/ReferencedEntry/); // Check that ReferencedEntry interface is not included
+    expect(generatedTS).toMatch(/\/\*\*.*\*\/\n\s*(export)/); // Check for Documentation is generated
+  });
 });
 
 describe("generateTS function with errors", () => {

tests/integration/generateTS/generateTS.test.ts

@@ -66,11 +66,11 @@ describe("graphqlTS function with errors", () => {
   });
 
   it("check for if wrong apiKey, token and environment is provided", async () => {
-    const token = "invalid-token";
-    const apiKey = process.env.APIKEY as unknown as any;
-    const environment = process.env.ENVIRONMENT as unknown as any;
-    const region = process.env.REGION as unknown as any;
-    const branch = process.env.BRANCH as unknown as any;
+    const token = "";
+    const apiKey = "";
+    const environment = "";
+    const region = "US";
+    const branch = "main";
 
     try {
       await graphqlTS({
@@ -81,8 +81,9 @@ describe("graphqlTS function with errors", () => {
         branch,
       });
     } catch (err: any) {
-      expect(err.error_message).toMatch(
-        /(unauthorized|invalid|not valid|error|failed)/i
+      expect(err.error_message).toBeDefined();
+      expect(err.error_message).toEqual(
+        "Please provide all the required params (token, apiKey, environment, region)"
       );
     }
   });