pi-harness-runtime 0.10.6 → 0.10.11

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

@@ -1,421 +0,0 @@
-/**
- * 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

@@ -1,265 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-{
-  "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"
-  ]
-}