pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/packages/test-data-generator/src/types.ts

@@ -0,0 +1,421 @@
+/**
+ * Test Data Generator - Types
+ *
+ * Core types for test data generation.
+ */
+
+// ─── SDK Version ────────────────────────────────────────────────────────────
+
+/**
+ * SDK version for compatibility checks
+ */
+export const SDK_VERSION = "1.0.0";
+
+// ─── Field Types ─────────────────────────────────────────────────────────────
+
+/**
+ * Field type for schema definition
+ */
+export type FieldType =
+	| "string"
+	| "number"
+	| "boolean"
+	| "date"
+	| "datetime"
+	| "email"
+	| "url"
+	| "phone"
+	| "uuid"
+	| "firstName"
+	| "lastName"
+	| "fullName"
+	| "address"
+	| "city"
+	| "country"
+	| "zipCode"
+	| "company"
+	| "department"
+	| "jobTitle"
+	| "paragraph"
+	| "sentence"
+	| "word"
+	| "lorem"
+	| "image"
+	| "avatar"
+	| "color"
+	| "hexColor"
+	| "rgbColor"
+	| "ipv4"
+	| "ipv6"
+	| "urlWithParams"
+	| "userName"
+	| "password"
+	| "creditCard"
+	| "currency"
+	| "locale"
+	| "fileName"
+	| "filePath"
+	| "mimeType"
+	| "latitude"
+	| "longitude"
+	| "array"
+	| "object"
+	| "enum"
+	| "oneOf"
+	| "relation"
+	| "custom";
+
+/**
+ * Field definition
+ */
+export interface FieldDefinition {
+	name: string;
+	type: FieldType;
+	options?: FieldOptions;
+	required?: boolean;
+	default?: unknown;
+	validate?: FieldValidator;
+}
+
+/**
+ * Field options
+ */
+export interface FieldOptions {
+	// String options
+	minLength?: number;
+	maxLength?: number;
+	pattern?: string;
+	prefix?: string;
+	suffix?: string;
+	uppercase?: boolean;
+	lowercase?: boolean;
+
+	// Number options
+	min?: number;
+	max?: number;
+	precision?: number;
+	integer?: boolean;
+	positive?: boolean;
+	negative?: boolean;
+	multipleOf?: number;
+
+	// Array options
+	length?: number;
+	minItems?: number;
+	maxItems?: number;
+	unique?: boolean;
+
+	// Date options
+	format?: string;
+	minDate?: string;
+	maxDate?: string;
+	past?: boolean;
+	future?: boolean;
+
+	// Enum options
+	values?: unknown[];
+	weights?: number[];
+
+	// Relation options
+	model?: string;
+	field?: string;
+	multiple?: boolean;
+
+	// Custom generator
+	generator?: CustomGenerator;
+}
+
+/**
+ * Field validator
+ */
+export interface FieldValidator {
+	validate: (value: unknown) => boolean;
+	message?: string;
+}
+
+/**
+ * Custom generator function
+ */
+export type CustomGenerator = (context: GeneratorContext) => unknown;
+
+/**
+ * Generator context
+ */
+export interface GeneratorContext {
+	field: FieldDefinition;
+	index: number;
+	seed: number;
+	data: Record<string, unknown>;
+	faker: FakerAdapter;
+}
+
+// ─── Schema Types ─────────────────────────────────────────────────────────────
+
+/**
+ * Schema definition
+ */
+export interface Schema {
+	name: string;
+	fields: FieldDefinition[];
+	relations?: RelationDefinition[];
+	hooks?: SchemaHooks;
+}
+
+/**
+ * Relation definition
+ */
+export interface RelationDefinition {
+	name: string;
+	type: RelationType;
+	target: string;
+	fields?: string[];
+}
+
+/**
+ * Relation type
+ */
+export type RelationType = "hasOne" | "hasMany" | "belongsTo" | "belongsToMany";
+
+/**
+ * Schema hooks
+ */
+export interface SchemaHooks {
+	beforeCreate?: (data: Record<string, unknown>) => Record<string, unknown>;
+	afterCreate?: (data: Record<string, unknown>) => Record<string, unknown>;
+	beforeBulkCreate?: (
+		data: Record<string, unknown>[],
+	) => Record<string, unknown>[];
+	afterBulkCreate?: (
+		data: Record<string, unknown>[],
+	) => Record<string, unknown>[];
+}
+
+// ─── Factory Types ─────────────────────────────────────────────────────────────
+
+/**
+ * Factory definition
+ */
+export interface Factory<T = Record<string, unknown>> {
+	name: string;
+	schema: Schema;
+	model?: string;
+	sequences?: Sequence[];
+	associations?: Association[];
+	afterCreate?: (data: T) => T | Promise<T>;
+	defaults?: Partial<T>;
+}
+
+/**
+ * Sequence for auto-incrementing fields
+ */
+export interface Sequence {
+	field: string;
+	start: number;
+	step: number;
+}
+
+/**
+ * Association definition
+ */
+export interface Association {
+	name: string;
+	factory: string;
+	type: "hasOne" | "hasMany" | "belongsTo" | "belongsToMany";
+	count?: number | { min: number; max: number };
+}
+
+// ─── Generation Types ──────────────────────────────────────────────────────────
+
+/**
+ * Generation request
+ */
+export interface GenerationRequest {
+	schema?: Schema;
+	schemaId?: string;
+	count: number;
+	data?: Partial<Record<string, unknown>>;
+	relations?: boolean;
+}
+
+/**
+ * Generated record
+ */
+export interface GeneratedRecord {
+	id: string;
+	data: Record<string, unknown>;
+	relations?: Record<string, GeneratedRecord[]>;
+	createdAt: string;
+}
+
+/**
+ * Generation result
+ */
+export interface GenerationResult {
+	success: boolean;
+	records: GeneratedRecord[];
+	count: number;
+	generationTimeMs: number;
+	errors?: GenerationError[];
+}
+
+/**
+ * Generation error
+ */
+export interface GenerationError {
+	field: string;
+	message: string;
+	value?: unknown;
+}
+
+// ─── Export Types ─────────────────────────────────────────────────────────────
+
+/**
+ * Export format
+ */
+export type ExportFormat =
+	| "json"
+	| "csv"
+	| "sql"
+	| "yaml"
+	| "fixtures"
+	| "typescript";
+
+/**
+ * Export options
+ */
+export interface ExportOptions {
+	format: ExportFormat;
+	pretty?: boolean;
+	includeRelations?: boolean;
+	flattenRelations?: boolean;
+	fileName?: string;
+	tableName?: string;
+	framework?: "frappe" | "django" | "laravel" | "nextjs";
+}
+
+/**
+ * Export result
+ */
+export interface ExportResult {
+	content: string;
+	format: ExportFormat;
+	fileName: string;
+	size: number;
+}
+
+// ─── Faker Adapter Types ──────────────────────────────────────────────────────
+
+/**
+ * Faker adapter interface
+ */
+export interface FakerAdapter {
+	string: (min?: number, max?: number) => string;
+	number: (min?: number, max?: number) => number;
+	boolean: () => boolean;
+	date: (options?: DateOptions) => Date;
+	email: () => string;
+	url: () => string;
+	phone: () => string;
+	uuid: () => string;
+	firstName: () => string;
+	lastName: () => string;
+	fullName: () => string;
+	address: () => string;
+	city: () => string;
+	country: () => string;
+	zipCode: () => string;
+	company: () => string;
+	department: () => string;
+	jobTitle: () => string;
+	paragraph: (sentences?: number) => string;
+	sentence: () => string;
+	word: () => string;
+	lorem: (words?: number) => string;
+	image: (width?: number, height?: number) => string;
+	avatar: () => string;
+	color: () => string;
+	hexColor: () => string;
+	ipv4: () => string;
+	ipv6: () => string;
+	userName: () => string;
+	password: (length?: number) => string;
+	creditCard: () => string;
+	currency: () => string;
+	locale: () => string;
+	fileName: (ext?: string) => string;
+	filePath: () => string;
+	mimeType: () => string;
+	latitude: () => number;
+	longitude: () => number;
+}
+
+/**
+ * Date generation options
+ */
+export interface DateOptions {
+	min?: Date;
+	max?: Date;
+	past?: boolean;
+	future?: boolean;
+}
+
+// ─── Configuration Types ──────────────────────────────────────────────────────
+
+/**
+ * Generator configuration
+ */
+export interface GeneratorConfig {
+	/**
+	 * Random seed for reproducibility
+	 */
+	seed?: number;
+
+	/**
+	 * Locale for data generation
+	 */
+	locale?: string;
+
+	/**
+	 * Enable logging
+	 */
+	verbose?: boolean;
+
+	/**
+	 * Maximum generation attempts
+	 */
+	maxRetries?: number;
+
+	/**
+	 * Custom faker adapters
+	 */
+	customGenerators?: Record<string, CustomGenerator>;
+}
+
+// ─── Fixtures Types ──────────────────────────────────────────────────────────
+
+/**
+ * Fixture format
+ */
+export interface Fixture {
+	name: string;
+	data: Record<string, unknown>[];
+	relations?: Record<string, string[]>;
+}
+
+/**
+ * Django fixture
+ */
+export interface DjangoFixture {
+	model: string;
+	pk: number;
+	fields: Record<string, unknown>;
+}
+
+/**
+ * Laravel factory
+ */
+export interface LaravelFactory {
+	name: string;
+	definition: Record<string, unknown>;
+	states?: string[];
+}

package/packages/test-data-generator/test/generator.test.ts

@@ -0,0 +1,265 @@
+/**
+ * Test Data Generator - Tests
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	createTestDataGenerator,
+	createFaker,
+	SDK_VERSION,
+} from "../src/index.js";
+
+describe("TestDataGenerator", () => {
+	describe("SDK_VERSION", () => {
+		it("should export SDK_VERSION", () => {
+			expect(SDK_VERSION).toBeDefined();
+			expect(typeof SDK_VERSION).toBe("string");
+		});
+	});
+
+	describe("createFaker", () => {
+		it("should create faker instance with seed", () => {
+			const faker = createFaker(12345);
+			expect(faker).toBeDefined();
+		});
+
+		it("should generate consistent data with same seed", () => {
+			const faker1 = createFaker(99999);
+			const faker2 = createFaker(99999);
+
+			const name1 = faker1.fullName();
+			const name2 = faker2.fullName();
+
+			expect(name1).toBe(name2);
+		});
+	});
+
+	describe("createTestDataGenerator", () => {
+		it("should create a test data generator instance", () => {
+			const generator = createTestDataGenerator();
+			expect(generator).toBeDefined();
+		});
+
+		it("should create with custom config", () => {
+			const generator = createTestDataGenerator({
+				seed: 12345,
+				verbose: true,
+			});
+			expect(generator).toBeDefined();
+		});
+	});
+
+	describe("data generation", () => {
+		const generator = createTestDataGenerator({
+			seed: 12345,
+		});
+
+		it("should generate data from schema", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "TestUser",
+					fields: [
+						{ name: "email", type: "email" },
+						{ name: "name", type: "fullName" },
+					],
+				},
+				count: 1,
+			});
+
+			expect(result.success).toBe(true);
+			expect(result.records.length).toBe(1);
+			expect(result.records[0].data.email).toContain("@");
+		});
+
+		it("should generate multiple records", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Users",
+					fields: [{ name: "name", type: "firstName" }],
+				},
+				count: 5,
+			});
+
+			expect(result.count).toBe(5);
+			expect(result.records.length).toBe(5);
+		});
+
+		it("should generate different data each run", async () => {
+			const gen1 = createTestDataGenerator({ seed: Date.now() });
+			const gen2 = createTestDataGenerator({ seed: Date.now() + 1 });
+
+			const result1 = await gen1.generate({
+				schema: {
+					name: "Random",
+					fields: [
+						{ name: "value", type: "number", options: { min: 1, max: 1000 } },
+					],
+				},
+				count: 1,
+			});
+
+			const result2 = await gen2.generate({
+				schema: {
+					name: "Random",
+					fields: [
+						{ name: "value", type: "number", options: { min: 1, max: 1000 } },
+					],
+				},
+				count: 1,
+			});
+
+			// Different seeds should produce different results
+			expect(typeof result1.records[0].data.value).toBe("number");
+			expect(typeof result2.records[0].data.value).toBe("number");
+		});
+
+		it("should validate required fields", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Required",
+					fields: [{ name: "name", type: "string", required: true }],
+				},
+				count: 1,
+			});
+
+			expect(result.success).toBe(true);
+		});
+
+		it("should use default values", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "WithDefaults",
+					fields: [
+						{
+							name: "status",
+							type: "enum",
+							options: { values: ["active"] },
+							default: "active",
+						},
+					],
+				},
+				count: 1,
+			});
+
+			expect(result.records[0].data.status).toBe("active");
+		});
+
+		it("should record generation time", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Timing",
+					fields: [{ name: "value", type: "number" }],
+				},
+				count: 1,
+			});
+
+			expect(result.generationTimeMs).toBeGreaterThanOrEqual(0);
+		});
+	});
+
+	describe("field types", () => {
+		const generator = createTestDataGenerator({ seed: 12345 });
+
+		it("should generate string fields", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Strings",
+					fields: [
+						{
+							name: "text",
+							type: "string",
+							options: { minLength: 5, maxLength: 10 },
+						},
+					],
+				},
+				count: 1,
+			});
+
+			const text = result.records[0].data.text as string;
+			expect(text.length).toBeGreaterThanOrEqual(5);
+			expect(text.length).toBeLessThanOrEqual(10);
+		});
+
+		it("should generate number fields", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Numbers",
+					fields: [
+						{ name: "age", type: "number", options: { min: 18, max: 99 } },
+					],
+				},
+				count: 1,
+			});
+
+			const age = result.records[0].data.age as number;
+			expect(age).toBeGreaterThanOrEqual(18);
+			expect(age).toBeLessThanOrEqual(99);
+		});
+
+		it("should generate boolean fields", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Booleans",
+					fields: [{ name: "active", type: "boolean" }],
+				},
+				count: 1,
+			});
+
+			const active = result.records[0].data.active;
+			expect(typeof active).toBe("boolean");
+		});
+
+		it("should generate enum fields", async () => {
+			const result = await generator.generate({
+				schema: {
+					name: "Enums",
+					fields: [
+						{
+							name: "status",
+							type: "enum",
+							options: { values: ["pending", "active", "done"] },
+						},
+					],
+				},
+				count: 10,
+			});
+
+			const statuses = result.records.map((r) => r.data.status);
+			statuses.forEach((status) => {
+				expect(["pending", "active", "done"]).toContain(status);
+			});
+		});
+	});
+
+	describe("schema registration", () => {
+		const generator = createTestDataGenerator();
+
+		it("should register schemas", () => {
+			generator.registerSchema({
+				name: "RegisteredUser",
+				fields: [{ name: "email", type: "email" }],
+			});
+
+			const schema = generator.getSchema("RegisteredUser");
+			expect(schema).toBeDefined();
+			expect(schema?.name).toBe("RegisteredUser");
+		});
+
+		it("should generate using registered schema", async () => {
+			generator.registerSchema({
+				name: "Product",
+				fields: [
+					{ name: "name", type: "company" },
+					{ name: "price", type: "number", options: { min: 1, max: 100 } },
+				],
+			});
+
+			const result = await generator.generate({
+				schemaId: "Product",
+				count: 1,
+			});
+
+			expect(result.success).toBe(true);
+		});
+	});
+});

package/packages/test-data-generator/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": [
+      "ES2022",
+      "DOM"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "composite": true,
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test"
+  ]
+}