Faker Args

Author: jcobis

packages/compass-collection/src/components/mock-data-generator-modal/script-generation-utils.spec.ts

@@ -495,4 +495,180 @@ describe('Script Generation', () => {
       }
     });
   });
+
+  describe('Faker Arguments', () => {
+    it('should handle string arguments', () => {
+      const schema = {
+        name: {
+          mongoType: 'string',
+          fakerMethod: 'person.firstName',
+          fakerArgs: ['male'],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'users',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain("faker.person.firstName('male')");
+      }
+    });
+
+    it('should handle number arguments', () => {
+      const schema = {
+        age: {
+          mongoType: 'number',
+          fakerMethod: 'number.int',
+          fakerArgs: [18, 65],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'users',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain('faker.number.int(18, 65)');
+      }
+    });
+
+    it('should handle boolean arguments', () => {
+      const schema = {
+        active: {
+          mongoType: 'boolean',
+          fakerMethod: 'datatype.boolean',
+          fakerArgs: [0.8],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'users',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain('faker.datatype.boolean(0.8)');
+      }
+    });
+
+    it('should handle JSON object arguments', () => {
+      const schema = {
+        score: {
+          mongoType: 'number',
+          fakerMethod: 'number.int',
+          fakerArgs: [{ json: '{"min":0,"max":100}' }],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'tests',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain(
+          'faker.number.int({"min":0,"max":100})'
+        );
+      }
+    });
+
+    it('should handle JSON arguments', () => {
+      const schema = {
+        color: {
+          mongoType: 'string',
+          fakerMethod: 'helpers.arrayElement',
+          fakerArgs: [{ json: "['red', 'blue', 'green']" }],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'items',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain(
+          "faker.helpers.arrayElement(['red', 'blue', 'green'])"
+        );
+      }
+    });
+
+    it('should handle mixed argument types', () => {
+      const schema = {
+        description: {
+          mongoType: 'string',
+          fakerMethod: 'lorem.words',
+          fakerArgs: [5, true],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'posts',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain('faker.lorem.words(5, true)');
+      }
+    });
+
+    it('should escape quotes in string arguments', () => {
+      const schema = {
+        quote: {
+          mongoType: 'string',
+          fakerMethod: 'lorem.sentence',
+          fakerArgs: ["It's a 'test' string"],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'quotes',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain(
+          "faker.lorem.sentence('It\\'s a \\'test\\' string')"
+        );
+      }
+    });
+
+    it('should handle empty arguments array', () => {
+      const schema = {
+        id: {
+          mongoType: 'string',
+          fakerMethod: 'string.uuid',
+          fakerArgs: [],
+        },
+      };
+
+      const result = generateScript(schema, {
+        databaseName: 'testdb',
+        collectionName: 'items',
+        documentCount: 1,
+      });
+
+      expect(result.success).to.equal(true);
+      if (result.success) {
+        expect(result.script).to.contain('faker.string.uuid()');
+      }
+    });
+  });
 });

packages/compass-collection/src/components/mock-data-generator-modal/script-generation-utils.ts

@@ -1,7 +1,9 @@
+export type FakerArg = string | number | boolean | { json: string };
+
 export interface FieldMapping {
   mongoType: string;
   fakerMethod: string;
-  fakerArgs: any[]; // TODO: type this properly later
+  fakerArgs: FakerArg[];
 }
 
 // Hierarchical array length map that mirrors document structure
@@ -239,15 +241,9 @@ export function generateScript(
       .replace(/'/g, "\\'")
       .replace(/`/g, '\\`');
 
-    // Validate document count
-    const documentCount = Math.max(
-      1,
-      Math.min(10000, Math.floor(options.documentCount)) // TODO
-    );
-
     const script = `// Mock Data Generator Script
 // Generated for collection: ${escapedDbName}.${escapedCollectionName}
-// Document count: ${documentCount}
+// Document count: ${options.documentCount}
 
 const { faker } = require('@faker-js/faker');
 
@@ -261,7 +257,7 @@ function generateDocument() {
 
 // Generate and insert documents
 const documents = [];
-for (let i = 0; i < ${documentCount}; i++) {
+for (let i = 0; i < ${options.documentCount}; i++) {
   documents.push(generateDocument());
 }
 
@@ -394,8 +390,8 @@ function generateFakerCall(mapping: FieldMapping): string {
       ? getDefaultFakerMethod(mapping.mongoType)
       : mapping.fakerMethod;
 
-  // TODO: Handle arguments properly
-  return `faker.${method}()`;
+  const args = formatFakerArgs(mapping.fakerArgs);
+  return `faker.${method}(${args})`;
 }
 
 /**
@@ -424,3 +420,26 @@ export function getDefaultFakerMethod(mongoType: string): string {
       return 'lorem.word';
   }
 }
+
+/**
+ * Converts faker arguments to JavaScript code
+ */
+export function formatFakerArgs(fakerArgs: FakerArg[]): string {
+  const stringifiedArgs: string[] = [];
+
+  for (const arg of fakerArgs) {
+    if (typeof arg === 'string') {
+      // Escape single quotes for JS strings (and backticks for security)
+      const escapedArg = arg.replace(/[`']/g, '\\$&');
+      stringifiedArgs.push(`'${escapedArg}'`);
+    } else if (typeof arg === 'number' || typeof arg === 'boolean') {
+      stringifiedArgs.push(`${arg}`);
+    } else if (typeof arg === 'object' && arg !== null && 'json' in arg) {
+      // Pre-serialized JSON objects
+      const jsonArg = arg as { json: string };
+      stringifiedArgs.push(jsonArg.json);
+    }
+  }
+
+  return stringifiedArgs.join(', ');
+}