nucleus-core-ts 0.8.0

package/scripts/generate-types-schema.ts

@@ -0,0 +1,962 @@
+#!/usr/bin/env bun
+/**
+ * This script generates JSON Schema files from TypeScript types in src/types.ts
+ * Run: bun run scripts/generate-types-schema.ts
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const TYPES_FILE = path.resolve(import.meta.dir, "../src/types.ts");
+const SCHEMAS_DIR = path.resolve(import.meta.dir, "../schemas");
+
+interface SchemaProperty {
+	type?: string | string[];
+	description?: string;
+	enum?: string[];
+	items?: SchemaProperty;
+	properties?: Record<string, SchemaProperty>;
+	required?: string[];
+	default?: unknown;
+	$ref?: string;
+	additionalProperties?: boolean | SchemaProperty;
+	minLength?: number;
+	maxLength?: number;
+	minimum?: number;
+	maximum?: number;
+}
+
+interface JsonSchema {
+	$id?: string;
+	$schema?: string;
+	title?: string;
+	description?: string;
+	type?: string;
+	properties?: Record<string, SchemaProperty>;
+	required?: string[];
+	$defs?: Record<string, SchemaProperty>;
+	additionalProperties?: boolean;
+}
+
+function parseTypesFile(): string {
+	return fs.readFileSync(TYPES_FILE, "utf-8");
+}
+
+function extractUnionType(content: string, typeName: string): string[] | null {
+	const regex = new RegExp(
+		`export type ${typeName}\\s*=([\\s\\S]*?)(?=export|$)`,
+	);
+	const match = content.match(regex);
+	if (!match || !match[1]) return null;
+
+	const body = match[1];
+	const values = body
+		.split("|")
+		.map((v) =>
+			v
+				.trim()
+				.replace(/^['"]|['"];?$/g, "")
+				.replace(/;$/, ""),
+		)
+		.filter(
+			(v) => v && !v.startsWith("//") && !v.includes("{") && v.length > 0,
+		);
+
+	return values;
+}
+
+function extractInterface(
+	content: string,
+	interfaceName: string,
+): { properties: Record<string, SchemaProperty>; required: string[] } | null {
+	const regex = new RegExp(
+		`export interface ${interfaceName}\\s*\\{([\\s\\S]*?)\\n\\}`,
+		"m",
+	);
+	const match = content.match(regex);
+	if (!match || !match[1]) return null;
+
+	const body = match[1];
+	const properties: Record<string, SchemaProperty> = {};
+	const required: string[] = [];
+
+	const lines = body.split("\n");
+	for (const line of lines) {
+		const propMatch = line.match(/^\s*(\w+)(\?)?:\s*(.+?);?\s*(?:\/\/.*)?$/);
+		if (!propMatch) continue;
+
+		const propName = propMatch[1];
+		const optional = propMatch[2];
+		const propType = propMatch[3];
+		if (!propName || !propType) continue;
+
+		const prop = parseTypeToSchema(propType.trim(), content);
+		properties[propName] = prop;
+
+		if (!optional) {
+			required.push(propName);
+		}
+	}
+
+	return { properties, required };
+}
+
+function parseTypeToSchema(typeStr: string, content: string): SchemaProperty {
+	typeStr = typeStr.replace(/;$/, "").trim();
+
+	if (typeStr === "string") return { type: "string" };
+	if (typeStr === "number") return { type: "number" };
+	if (typeStr === "boolean") return { type: "boolean" };
+	if (typeStr === "unknown" || typeStr === "any") return {};
+	if (typeStr === "string[]")
+		return { type: "array", items: { type: "string" } };
+	if (typeStr === "number[]")
+		return { type: "array", items: { type: "number" } };
+
+	if (typeStr.startsWith("'") || typeStr.startsWith('"')) {
+		const enumValue = typeStr.replace(/^['"]|['"]$/g, "");
+		return { type: "string", enum: [enumValue] };
+	}
+
+	const unionMatch = typeStr.match(
+		/^(['"][^'"]+['"](?:\s*\|\s*['"][^'"]+['"])+)$/,
+	);
+	if (unionMatch) {
+		const values = typeStr
+			.split("|")
+			.map((v) => v.trim().replace(/^['"]|['"]$/g, ""));
+		return { type: "string", enum: values };
+	}
+
+	const arrayMatch = typeStr.match(/^(.+)\[\]$/);
+	if (arrayMatch?.[1]) {
+		return { type: "array", items: parseTypeToSchema(arrayMatch[1], content) };
+	}
+
+	const recordMatch = typeStr.match(/^Record<string,\s*(.+)>$/);
+	if (recordMatch?.[1]) {
+		return {
+			type: "object",
+			additionalProperties: parseTypeToSchema(recordMatch[1], content),
+		};
+	}
+
+	const objectMatch = typeStr.match(/^\{([^}]+)\}$/);
+	if (objectMatch?.[1]) {
+		const props: Record<string, SchemaProperty> = {};
+		const innerProps = objectMatch[1].split(/[,;]/).filter((p) => p.trim());
+		for (const prop of innerProps) {
+			const m = prop.trim().match(/^(\w+)(\?)?:\s*(.+)$/);
+			if (m?.[1] && m[3]) {
+				props[m[1]] = parseTypeToSchema(m[3], content);
+			}
+		}
+		return { type: "object", properties: props };
+	}
+
+	const knownUnion = extractUnionType(content, typeStr);
+	if (knownUnion) {
+		return { type: "string", enum: knownUnion };
+	}
+
+	const knownInterface = extractInterface(content, typeStr);
+	if (knownInterface) {
+		return {
+			type: "object",
+			properties: knownInterface.properties,
+			required:
+				knownInterface.required.length > 0
+					? knownInterface.required
+					: undefined,
+		};
+	}
+
+	return { type: "string" };
+}
+
+function generateNucleusTableSchema(content: string): JsonSchema {
+	const columnTypes = extractUnionType(content, "NucleusColumnType") || [];
+	const fkActions = extractUnionType(content, "NucleusFKAction") || [];
+	const indexMethods = extractUnionType(content, "NucleusIndexMethod") || [];
+	const columnModes = extractUnionType(content, "NucleusColumnMode") || [];
+	const sanitizeOptions =
+		extractUnionType(content, "NucleusSanitizeOption") || [];
+	const methods = extractUnionType(content, "GenericNucleusMethods") || [];
+	const featureSets = extractUnionType(content, "SystemTableFeatureSets") || [];
+	const validationFormats = [
+		"email",
+		"url",
+		"uuid",
+		"date",
+		"datetime",
+		"time",
+		"uri",
+		"ipv4",
+		"ipv6",
+	];
+
+	const columnReference: SchemaProperty = {
+		type: "object",
+		properties: {
+			table: { type: "string", description: "Referenced table name" },
+			column: { type: "string", description: "Referenced column name" },
+			onDelete: {
+				type: "string",
+				enum: fkActions,
+				description: "ON DELETE action",
+			},
+			onUpdate: {
+				type: "string",
+				enum: fkActions,
+				description: "ON UPDATE action",
+			},
+		},
+		required: ["table"],
+	};
+
+	const columnEnum: SchemaProperty = {
+		type: "object",
+		properties: {
+			name: { type: "string", description: "Enum type name" },
+			values: {
+				type: "array",
+				items: { type: "string" },
+				description: "Enum values",
+			},
+		},
+		required: ["name", "values"],
+	};
+
+	const columnValidation: SchemaProperty = {
+		type: "object",
+		properties: {
+			minLength: { type: "number" },
+			maxLength: { type: "number" },
+			min: { type: "number" },
+			max: { type: "number" },
+			pattern: { type: "string" },
+			format: { type: "string", enum: validationFormats },
+			customMessage: { type: "string" },
+		},
+	};
+
+	const column: SchemaProperty = {
+		type: "object",
+		properties: {
+			name: { type: "string", description: "Column name", minLength: 1 },
+			type: {
+				type: "string",
+				description: "Drizzle PostgreSQL column type",
+				enum: columnTypes,
+			},
+			length: {
+				type: "number",
+				description: "Column length (for varchar, char)",
+			},
+			precision: { type: "number", description: "Numeric precision" },
+			scale: { type: "number", description: "Numeric scale" },
+			dimensions: { type: "number", description: "Vector dimensions" },
+			mode: { type: "string", enum: columnModes, description: "Column mode" },
+			withTimezone: {
+				type: "boolean",
+				description: "Include timezone for timestamp types",
+			},
+			nullable: { type: "boolean", description: "Column is nullable" },
+			notNull: { type: "boolean", description: "Column is NOT NULL" },
+			unique: { type: "boolean", description: "Column has unique constraint" },
+			primaryKey: { type: "boolean", description: "Column is primary key" },
+			default: { description: "Default value" },
+			defaultRaw: { type: "string", description: "Raw SQL default expression" },
+			references: { $ref: "#/$defs/columnReference" },
+			array: { type: "boolean", description: "Column is array type" },
+			arrayDimensions: { type: "number", description: "Array dimensions" },
+			enumValues: {
+				type: "array",
+				items: { type: "string" },
+				description: "Enum values (shorthand)",
+			},
+			enum: { $ref: "#/$defs/columnEnum" },
+			generatedAlwaysAs: {
+				type: "string",
+				description: "Generated column expression",
+			},
+			generatedAlwaysAsIdentity: { type: "boolean" },
+			generatedByDefaultAsIdentity: { type: "boolean" },
+			check: { type: "string", description: "Check constraint expression" },
+			comment: { type: "string", description: "Column comment" },
+			validation: { $ref: "#/$defs/columnValidation" },
+			sanitize: {
+				type: "array",
+				items: { type: "string", enum: sanitizeOptions },
+				description: "Sanitize options",
+			},
+		},
+		required: ["name", "type"],
+	};
+
+	const index: SchemaProperty = {
+		type: "object",
+		properties: {
+			name: { type: "string", description: "Index name" },
+			columns: {
+				type: "array",
+				items: { type: "string" },
+				description: "Indexed columns",
+			},
+			unique: { type: "boolean", description: "Unique index" },
+			using: {
+				type: "string",
+				enum: indexMethods,
+				description: "Index method",
+			},
+			where: { type: "string", description: "Partial index WHERE clause" },
+			concurrently: {
+				type: "boolean",
+				description: "Create index concurrently",
+			},
+		},
+		required: ["columns"],
+	};
+
+	const uniqueConstraint: SchemaProperty = {
+		type: "object",
+		properties: {
+			name: { type: "string" },
+			columns: { type: "array", items: { type: "string" } },
+		},
+		required: ["columns"],
+	};
+
+	const checkConstraint: SchemaProperty = {
+		type: "object",
+		properties: {
+			name: { type: "string" },
+			expression: { type: "string" },
+		},
+		required: ["expression"],
+	};
+
+	const constraints: SchemaProperty = {
+		type: "object",
+		properties: {
+			primaryKey: { type: "array", items: { type: "string" } },
+			unique: { type: "array", items: { $ref: "#/$defs/uniqueConstraint" } },
+			check: { type: "array", items: { $ref: "#/$defs/checkConstraint" } },
+		},
+	};
+
+	const isPublicProps: Record<string, SchemaProperty> = {};
+	for (const method of methods) {
+		isPublicProps[method] = { type: "boolean", default: false };
+	}
+
+	const schema: JsonSchema = {
+		$id: "table.schema.json",
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		title: "Nucleus Table Definition",
+		description: "Generated from NucleusTable interface in types.ts",
+		type: "object",
+		properties: {
+			table_name: {
+				type: "string",
+				description: "Table name in database",
+				minLength: 1,
+				maxLength: 100,
+			},
+			feature_set: {
+				type: "array",
+				items: { type: "string", enum: featureSets },
+				description: "Feature set this table belongs to",
+			},
+			add_base_columns: {
+				type: "boolean",
+				description: "Add base columns (id, created_at, etc.)",
+				default: true,
+			},
+			is_form_data: {
+				type: "boolean",
+				description: "Entity needs multipart form data",
+				default: false,
+			},
+			available_app_ids: {
+				type: "array",
+				items: { type: "string" },
+				description: "Available app IDs",
+				default: ["*"],
+			},
+			available_schemas: {
+				type: "array",
+				items: { type: "string" },
+				description: "Available schemas",
+				default: ["*"],
+			},
+			excluded_schemas: {
+				type: "array",
+				items: { type: "string" },
+				description: "Excluded schemas",
+			},
+			excluded_methods: {
+				type: "array",
+				items: { type: "string", enum: methods },
+				description: "Excluded HTTP methods",
+			},
+			is_public: {
+				type: "object",
+				description: "Public access per method",
+				properties: isPublicProps,
+			},
+			columns: {
+				type: "array",
+				items: { $ref: "#/$defs/column" },
+				description: "Column definitions",
+			},
+			indexes: {
+				type: "array",
+				items: { $ref: "#/$defs/index" },
+				description: "Index definitions",
+			},
+			constraints: { $ref: "#/$defs/constraints" },
+			group_name: {
+				type: "string",
+				description: "Group name for organization",
+				minLength: 1,
+			},
+			bulk_endpoints_enabled: {
+				type: "boolean",
+				description: "Enable bulk endpoints",
+				default: false,
+			},
+		},
+		required: ["table_name"],
+		additionalProperties: false,
+		$defs: {
+			column,
+			index,
+			constraints,
+			uniqueConstraint,
+			checkConstraint,
+			columnReference,
+			columnEnum,
+			columnValidation,
+		},
+	};
+
+	return schema;
+}
+
+function generateNucleusConfigSchema(_content: string): JsonSchema {
+	// const methods = extractUnionType(content, "GenericNucleusMethods") || [];
+
+	const tokenConfig: SchemaProperty = {
+		type: "object",
+		properties: {
+			secret: {
+				type: "string",
+				description: "Environment variable name for JWT secret",
+			},
+			expiresIn: {
+				type: "string",
+				description: 'Token expiration (e.g., "15m", "7d")',
+			},
+			algorithm: {
+				type: "string",
+				enum: [
+					"HS256",
+					"HS384",
+					"HS512",
+					"RS256",
+					"RS384",
+					"RS512",
+					"ES256",
+					"ES384",
+					"ES512",
+					"PS256",
+					"PS384",
+					"PS512",
+				],
+				description: "JWT algorithm",
+			},
+			issuer: { type: "string", description: "Token issuer" },
+			audience: { type: "string", description: "Token audience" },
+			name: { type: "string", description: "Cookie name" },
+			setHeadersEnabled: {
+				type: "boolean",
+				description: "Set token in response headers",
+			},
+			returnJson: {
+				type: "boolean",
+				description: "Return token in JSON response",
+			},
+		},
+	};
+
+	const routeConfig: SchemaProperty = {
+		type: "object",
+		properties: {
+			route: { type: "string", description: "Custom route path" },
+			isPublic: {
+				type: "boolean",
+				description: "Route is public (no auth required)",
+			},
+			enabled: { type: "boolean", description: "Route is enabled" },
+		},
+	};
+
+	const rateLimitRoute: SchemaProperty = {
+		type: "object",
+		properties: {
+			window: { type: "string", description: 'Time window (e.g., "1m", "1h")' },
+			max: { type: "number", description: "Maximum requests in window" },
+			blockDuration: {
+				type: "string",
+				description: "Block duration after limit exceeded",
+			},
+		},
+	};
+
+	const schema: JsonSchema = {
+		$id: "config.nucleus.json",
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		title: "Nucleus Config",
+		description: "Generated from NucleusConfigOptions interface in types.ts",
+		type: "object",
+		properties: {
+			$schema: { type: "string", description: "JSON Schema reference" },
+			appId: { type: "string", description: "Application ID", minLength: 1 },
+			mode: {
+				type: "string",
+				enum: ["development", "production"],
+				default: "development",
+			},
+			database: {
+				type: "object",
+				properties: {
+					url: {
+						type: "string",
+						description: "Environment variable name for database URL",
+					},
+					type: { type: "string", enum: ["postgres"], default: "postgres" },
+					isMultiTenant: { type: "boolean", default: false },
+					schemas: {
+						type: "array",
+						items: { type: "string" },
+						default: ["main"],
+					},
+					allowDataLoss: { type: "boolean", default: false },
+				},
+			},
+			redis: {
+				type: "object",
+				properties: {
+					url: {
+						type: "string",
+						description: "Environment variable name for Redis URL",
+					},
+					host: { type: "string" },
+					port: { type: "number" },
+					withDapr: { type: "boolean" },
+					stateStoreName: { type: "string" },
+				},
+			},
+			authentication: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean", default: false },
+					accessToken: tokenConfig,
+					refreshToken: tokenConfig,
+					sessionToken: tokenConfig,
+					login: {
+						type: "object",
+						properties: {
+							route: { type: "string" },
+							rememberMe: { type: "boolean" },
+							isPublic: { type: "boolean" },
+							enabled: { type: "boolean" },
+						},
+					},
+					register: routeConfig,
+					logout: routeConfig,
+					refresh: routeConfig,
+					passwordReset: {
+						type: "object",
+						properties: {
+							route: { type: "string" },
+							isPublic: { type: "boolean" },
+							enabled: { type: "boolean" },
+							redirectUrl: { type: "string" },
+						},
+					},
+					passwordChange: routeConfig,
+					sessions: {
+						type: "object",
+						properties: {
+							route: { type: "string" },
+							isPublic: { type: "boolean" },
+							enabled: { type: "boolean" },
+							maxActiveSessions: { type: "number" },
+							inactivityTimeout: { type: "string" },
+							allowMultipleDevices: { type: "boolean" },
+							trustNewDevices: { type: "boolean" },
+							notifyOnNewDevice: { type: "boolean" },
+						},
+					},
+					magicLink: {
+						type: "object",
+						properties: {
+							route: { type: "string" },
+							verifyRoute: { type: "string" },
+							isPublic: { type: "boolean" },
+							enabled: { type: "boolean" },
+							expiresIn: { type: "string" },
+							redirectUrl: { type: "string" },
+						},
+					},
+					me: {
+						type: "object",
+						properties: {
+							route: { type: "string" },
+							isPublic: { type: "boolean" },
+							enabled: { type: "boolean" },
+							includeProfile: { type: "boolean" },
+							includeAddresses: { type: "boolean" },
+							includePhones: { type: "boolean" },
+							includeFiles: { type: "boolean" },
+						},
+					},
+				},
+			},
+			authorization: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean", default: false },
+					autoSeedClaims: { type: "boolean", default: true },
+					skipTables: { type: "array", items: { type: "string" } },
+					skipColumns: { type: "array", items: { type: "string" } },
+					excludedPaths: { type: "array", items: { type: "string" } },
+					publicPaths: { type: "array", items: { type: "string" } },
+					godminEmail: { type: "string" },
+					godminPassword: { type: "string" },
+				},
+			},
+			audit: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean", default: false },
+					actions: {
+						type: "object",
+						properties: {
+							GET: { type: "boolean" },
+							INSERT: { type: "boolean" },
+							UPDATE: { type: "boolean" },
+							DELETE: { type: "boolean" },
+							TOGGLE: { type: "boolean" },
+							VERIFICATION: { type: "boolean" },
+						},
+					},
+				},
+			},
+			verification: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean" },
+					autoResetOnRejection: { type: "boolean" },
+					requireSignatureByDefault: { type: "boolean" },
+					diffTrackingEnabled: { type: "boolean" },
+					endpoints: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							basePath: { type: "string" },
+						},
+					},
+				},
+			},
+			notification: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean" },
+					portalEnabled: { type: "boolean" },
+					emailEnabled: { type: "boolean" },
+					defaultChannel: { type: "string", enum: ["portal", "email", "both"] },
+					templateVariables: {
+						type: "object",
+						additionalProperties: { type: "string" },
+					},
+				},
+			},
+			rateLimit: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean" },
+					strategy: {
+						type: "string",
+						enum: ["sliding-window", "fixed-window", "token-bucket"],
+					},
+					keyPrefix: { type: "string" },
+					authRoutes: {
+						type: "object",
+						properties: {
+							window: { type: "string" },
+							max: { type: "number" },
+							login: rateLimitRoute,
+							register: rateLimitRoute,
+							passwordReset: rateLimitRoute,
+							magicLink: rateLimitRoute,
+						},
+					},
+					publicRoutes: {
+						type: "object",
+						properties: { window: { type: "string" }, max: { type: "number" } },
+					},
+					privateRoutes: {
+						type: "object",
+						properties: { window: { type: "string" }, max: { type: "number" } },
+					},
+					byIp: { type: "boolean" },
+					byUserId: { type: "boolean" },
+					byEndpoint: { type: "boolean" },
+					skipSuccessfulRequests: { type: "boolean" },
+					headers: {
+						type: "object",
+						properties: {
+							remaining: { type: "string" },
+							reset: { type: "string" },
+							limit: { type: "string" },
+						},
+					},
+					whitelist: { type: "array", items: { type: "string" } },
+					blacklist: { type: "array", items: { type: "string" } },
+				},
+			},
+			monitoring: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean" },
+					system: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							collectInterval: { type: "string" },
+							metrics: {
+								type: "object",
+								properties: {
+									cpu: { type: "boolean" },
+									memory: { type: "boolean" },
+									disk: { type: "boolean" },
+									network: { type: "boolean" },
+									process: { type: "boolean" },
+								},
+							},
+						},
+					},
+					application: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							metrics: {
+								type: "object",
+								properties: {
+									requests: { type: "boolean" },
+									responseTime: { type: "boolean" },
+									errors: { type: "boolean" },
+									rateLimits: { type: "boolean" },
+								},
+							},
+						},
+					},
+					database: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							metrics: {
+								type: "object",
+								properties: {
+									connections: { type: "boolean" },
+									queryTime: { type: "boolean" },
+									slowQueryThreshold: { type: "string" },
+								},
+							},
+						},
+					},
+					redis: {
+						type: "object",
+						properties: { enabled: { type: "boolean" } },
+					},
+					persistence: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							flushInterval: { type: "string" },
+							retentionDays: { type: "number" },
+						},
+					},
+					alerts: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							email: {
+								type: "object",
+								properties: {
+									enabled: { type: "boolean" },
+									recipients: { type: "array", items: { type: "string" } },
+								},
+							},
+							thresholds: {
+								type: "object",
+								properties: {
+									cpuPercent: { type: "number" },
+									memoryPercent: { type: "number" },
+									diskPercent: { type: "number" },
+									errorRatePercent: { type: "number" },
+									responseTimeMs: { type: "number" },
+									rateLimitBlocksPerMinute: { type: "number" },
+								},
+							},
+							cooldown: { type: "string" },
+						},
+					},
+					endpoints: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							basePath: { type: "string" },
+							stream: {
+								type: "object",
+								properties: {
+									enabled: { type: "boolean" },
+									path: { type: "string" },
+									interval: { type: "string" },
+								},
+							},
+							snapshot: {
+								type: "object",
+								properties: {
+									enabled: { type: "boolean" },
+									path: { type: "string" },
+								},
+							},
+							history: {
+								type: "object",
+								properties: {
+									enabled: { type: "boolean" },
+									path: { type: "string" },
+									maxMinutes: { type: "number" },
+								},
+							},
+							alerts: {
+								type: "object",
+								properties: {
+									enabled: { type: "boolean" },
+									path: { type: "string" },
+								},
+							},
+						},
+					},
+				},
+			},
+			email: {
+				type: "object",
+				properties: {
+					gmail: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							json_file_path: { type: "string" },
+							from_email: { type: "string" },
+							from_name: { type: "string" },
+						},
+					},
+				},
+			},
+			storage: {
+				type: "object",
+				properties: {
+					enabled: { type: "boolean" },
+					basePath: { type: "string" },
+					maxFileSizeBytes: { type: "number" },
+					allowedMimeTypes: { type: "array", items: { type: "string" } },
+					blockedMimeTypes: { type: "array", items: { type: "string" } },
+					cdn: {
+						type: "object",
+						properties: {
+							enabled: { type: "boolean" },
+							basePath: { type: "string" },
+							cacheMaxAge: { type: "number" },
+							enableRangeRequests: { type: "boolean" },
+							enableEtag: { type: "boolean" },
+							corsOrigins: { type: "array", items: { type: "string" } },
+						},
+					},
+					formData: {
+						type: "object",
+						properties: {
+							filesField: { type: "string" },
+							dataField: { type: "string" },
+							maxFiles: { type: "number" },
+						},
+					},
+				},
+			},
+			entities: {
+				type: "array",
+				description: "Entity/table definitions",
+				items: { $ref: "table.schema.json" },
+			},
+		},
+		required: ["appId", "entities"],
+		additionalProperties: false,
+	};
+
+	return schema;
+}
+
+function generateTablesArraySchema(): JsonSchema {
+	return {
+		$id: "nucleus.tables.schema.json",
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		title: "Nucleus Tables Array",
+		description: "Array of Nucleus table definitions",
+		type: "object",
+		properties: {
+			$schema: { type: "string" },
+			tables: {
+				type: "array",
+				items: { $ref: "table.schema.json" },
+			},
+		},
+		required: ["tables"],
+	};
+}
+
+function main() {
+	console.log("🔄 Reading types.ts...");
+	const content = parseTypesFile();
+
+	console.log("📝 Generating table.schema.json...");
+	const tableSchema = generateNucleusTableSchema(content);
+	fs.writeFileSync(
+		path.join(SCHEMAS_DIR, "table.schema.json"),
+		JSON.stringify(tableSchema, null, 2),
+	);
+
+	console.log("📝 Generating config.nucleus.json...");
+	const configSchema = generateNucleusConfigSchema(content);
+	fs.writeFileSync(
+		path.join(SCHEMAS_DIR, "config.nucleus.json"),
+		JSON.stringify(configSchema, null, 2),
+	);
+
+	console.log("📝 Generating nucleus.tables.schema.json...");
+	const tablesSchema = generateTablesArraySchema();
+	fs.writeFileSync(
+		path.join(SCHEMAS_DIR, "nucleus.tables.schema.json"),
+		JSON.stringify(tablesSchema, null, 2),
+	);
+
+	console.log("✅ Schemas generated successfully!");
+	console.log(`   - ${SCHEMAS_DIR}/table.schema.json`);
+	console.log(`   - ${SCHEMAS_DIR}/config.nucleus.json`);
+	console.log(`   - ${SCHEMAS_DIR}/nucleus.tables.schema.json`);
+}
+
+main();