nucleus-core-ts 0.8.0

package/schemas/nucleus.tables.schema.json

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

package/schemas/table.schema.json

@@ -0,0 +1,498 @@
+{
+	"$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": [
+					"authentication",
+					"authorization",
+					"audit",
+					"notification",
+					"verification"
+				]
+			},
+			"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": [
+					"GET",
+					"POST",
+					"PUT",
+					"DELETE",
+					"PATCH",
+					"TOGGLE",
+					"VERIFICATION"
+				]
+			},
+			"description": "Excluded HTTP methods"
+		},
+		"is_public": {
+			"type": "object",
+			"description": "Public access per method",
+			"properties": {
+				"GET": {
+					"type": "boolean",
+					"default": false
+				},
+				"POST": {
+					"type": "boolean",
+					"default": false
+				},
+				"PUT": {
+					"type": "boolean",
+					"default": false
+				},
+				"DELETE": {
+					"type": "boolean",
+					"default": false
+				},
+				"PATCH": {
+					"type": "boolean",
+					"default": false
+				},
+				"TOGGLE": {
+					"type": "boolean",
+					"default": false
+				},
+				"VERIFICATION": {
+					"type": "boolean",
+					"default": false
+				}
+			}
+		},
+		"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": {
+			"type": "object",
+			"properties": {
+				"name": {
+					"type": "string",
+					"description": "Column name",
+					"minLength": 1
+				},
+				"type": {
+					"type": "string",
+					"description": "Drizzle PostgreSQL column type",
+					"enum": [
+						"integer",
+						"smallint",
+						"bigint",
+						"serial",
+						"smallserial",
+						"bigserial",
+						"real",
+						"doublePrecision",
+						"numeric",
+						"decimal",
+						"text",
+						"varchar",
+						"char",
+						"uuid",
+						"boolean",
+						"date",
+						"time",
+						"timestamp",
+						"timestamptz",
+						"interval",
+						"json",
+						"jsonb",
+						"bytea",
+						"inet",
+						"cidr",
+						"macaddr",
+						"macaddr8",
+						"bit",
+						"bitVarying",
+						"point",
+						"line",
+						"lseg",
+						"box",
+						"path",
+						"polygon",
+						"circle",
+						"tsvector",
+						"tsquery",
+						"xml",
+						"money",
+						"int4range",
+						"int8range",
+						"numrange",
+						"tsrange",
+						"tstzrange",
+						"daterange",
+						"int4multirange",
+						"int8multirange",
+						"nummultirange",
+						"tsmultirange",
+						"tstzmultirange",
+						"datemultirange",
+						"vector",
+						"geometry",
+						"geography",
+						"customType"
+					]
+				},
+				"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": ["string", "date", "json", "number"],
+					"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": [
+							"trim",
+							"lowercase",
+							"uppercase",
+							"escapeHtml",
+							"stripTags",
+							"normalizeEmail",
+							"toNumber",
+							"toBoolean",
+							"slugify"
+						]
+					},
+					"description": "Sanitize options"
+				}
+			},
+			"required": ["name", "type"]
+		},
+		"index": {
+			"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": ["btree", "hash", "gist", "spgist", "gin", "brin"],
+					"description": "Index method"
+				},
+				"where": {
+					"type": "string",
+					"description": "Partial index WHERE clause"
+				},
+				"concurrently": {
+					"type": "boolean",
+					"description": "Create index concurrently"
+				}
+			},
+			"required": ["columns"]
+		},
+		"constraints": {
+			"type": "object",
+			"properties": {
+				"primaryKey": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					}
+				},
+				"unique": {
+					"type": "array",
+					"items": {
+						"$ref": "#/$defs/uniqueConstraint"
+					}
+				},
+				"check": {
+					"type": "array",
+					"items": {
+						"$ref": "#/$defs/checkConstraint"
+					}
+				}
+			}
+		},
+		"uniqueConstraint": {
+			"type": "object",
+			"properties": {
+				"name": {
+					"type": "string"
+				},
+				"columns": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					}
+				}
+			},
+			"required": ["columns"]
+		},
+		"checkConstraint": {
+			"type": "object",
+			"properties": {
+				"name": {
+					"type": "string"
+				},
+				"expression": {
+					"type": "string"
+				}
+			},
+			"required": ["expression"]
+		},
+		"columnReference": {
+			"type": "object",
+			"properties": {
+				"table": {
+					"type": "string",
+					"description": "Referenced table name"
+				},
+				"column": {
+					"type": "string",
+					"description": "Referenced column name"
+				},
+				"onDelete": {
+					"type": "string",
+					"enum": [
+						"cascade",
+						"restrict",
+						"no action",
+						"set null",
+						"set default"
+					],
+					"description": "ON DELETE action"
+				},
+				"onUpdate": {
+					"type": "string",
+					"enum": [
+						"cascade",
+						"restrict",
+						"no action",
+						"set null",
+						"set default"
+					],
+					"description": "ON UPDATE action"
+				}
+			},
+			"required": ["table"]
+		},
+		"columnEnum": {
+			"type": "object",
+			"properties": {
+				"name": {
+					"type": "string",
+					"description": "Enum type name"
+				},
+				"values": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					},
+					"description": "Enum values"
+				}
+			},
+			"required": ["name", "values"]
+		},
+		"columnValidation": {
+			"type": "object",
+			"properties": {
+				"minLength": {
+					"type": "number"
+				},
+				"maxLength": {
+					"type": "number"
+				},
+				"min": {
+					"type": "number"
+				},
+				"max": {
+					"type": "number"
+				},
+				"pattern": {
+					"type": "string"
+				},
+				"format": {
+					"type": "string",
+					"enum": [
+						"email",
+						"url",
+						"uuid",
+						"date",
+						"datetime",
+						"time",
+						"uri",
+						"ipv4",
+						"ipv6"
+					]
+				},
+				"customMessage": {
+					"type": "string"
+				}
+			}
+		}
+	}
+}

package/scripts/build.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env bun
+
+/**
+ * Nucleus Core Build Script
+ * Compiles TypeScript, bundles, and obfuscates the output
+ */
+
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { $ } from "bun";
+import config from "../nucleus.config";
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const RED = "\x1b[31m";
+const NC = "\x1b[0m";
+
+const log = {
+	info: (msg: string) => console.log(`${BLUE}ℹ️  ${msg}${NC}`),
+	success: (msg: string) => console.log(`${GREEN}✅ ${msg}${NC}`),
+	warn: (msg: string) => console.log(`${YELLOW}⚠️  ${msg}${NC}`),
+	error: (msg: string) => console.log(`${RED}❌ ${msg}${NC}`),
+	step: (n: number, total: number, msg: string) =>
+		console.log(`\n${BLUE}[${n}/${total}]${NC} ${msg}`),
+};
+
+async function cleanDist() {
+	log.info("Cleaning dist directory...");
+	await rm(config.build.outDir, { recursive: true, force: true });
+	await mkdir(config.build.outDir, { recursive: true });
+	log.success("Dist cleaned");
+}
+
+async function buildWithBun() {
+	log.info("Building with Bun...");
+
+	const entryPoints = Object.values(config.entryPoints);
+	const externals = config.externals.map((e) => `--external ${e}`).join(" ");
+
+	const cmd = `bun build ${entryPoints.join(" ")} --outdir=${config.build.outDir} --target=${config.build.target} --format=${config.build.format} ${config.build.splitting ? "--splitting" : ""} ${config.build.minify ? "--minify" : ""} ${externals}`;
+
+	const result = await $`${{ raw: cmd }}`.quiet();
+
+	if (result.exitCode !== 0) {
+		throw new Error(`Build failed: ${result.stderr.toString()}`);
+	}
+
+	log.success("Bun build completed");
+}
+
+async function generateTypes() {
+	log.info("Generating type definitions...");
+
+	try {
+		await $`bunx tsc --declaration --emitDeclarationOnly --outDir ${config.build.outDir} --skipLibCheck`.quiet();
+		log.success("Type definitions generated");
+	} catch {
+		log.warn("Some type errors occurred, but continuing...");
+	}
+}
+
+async function getJsFiles(dir: string): Promise<string[]> {
+	const files: string[] = [];
+
+	async function walk(currentDir: string) {
+		const entries = await readdir(currentDir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			const fullPath = join(currentDir, entry.name);
+
+			if (entry.isDirectory()) {
+				await walk(fullPath);
+			} else if (entry.name.endsWith(".js") && !entry.name.endsWith(".d.ts")) {
+				const relativePath = relative(config.build.outDir, fullPath);
+				const shouldExclude = config.obfuscationExclude.some((pattern) => {
+					if (pattern.includes("*")) {
+						const regex = new RegExp(
+							pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"),
+						);
+						return regex.test(relativePath);
+					}
+					return relativePath.includes(pattern);
+				});
+
+				if (!shouldExclude) {
+					files.push(fullPath);
+				}
+			}
+		}
+	}
+
+	await walk(dir);
+	return files;
+}
+
+async function obfuscateFiles() {
+	if (!config.obfuscation.enabled) {
+		log.warn("Obfuscation disabled in config");
+		return;
+	}
+
+	log.info(`Obfuscating with level: ${config.obfuscation.level}`);
+
+	const JavaScriptObfuscator = await import("javascript-obfuscator");
+	const obfuscatorOptions =
+		config.obfuscation.options[config.obfuscation.level];
+
+	const jsFiles = await getJsFiles(config.build.outDir);
+	log.info(`Found ${jsFiles.length} JavaScript files to obfuscate`);
+
+	let processed = 0;
+	for (const file of jsFiles) {
+		try {
+			const code = await readFile(file, "utf-8");
+
+			const obfuscated = JavaScriptObfuscator.obfuscate(code, {
+				...(obfuscatorOptions as Record<string, unknown>),
+				sourceMap: false,
+			} as Parameters<typeof JavaScriptObfuscator.obfuscate>[1]);
+
+			await writeFile(file, obfuscated.getObfuscatedCode());
+			processed++;
+
+			process.stdout.write(
+				`\r  Obfuscating: ${processed}/${jsFiles.length} files`,
+			);
+		} catch (err) {
+			log.warn(`Failed to obfuscate ${file}: ${err}`);
+		}
+	}
+
+	console.log("");
+	log.success(`Obfuscated ${processed} files`);
+}
+
+async function removeSourceMaps() {
+	log.info("Removing any source maps...");
+	await $`find ${config.build.outDir} -name "*.map" -delete`.quiet();
+	log.success("Source maps removed");
+}
+
+async function verifyBuild() {
+	log.info("Verifying build output...");
+
+	for (const [exportPath, entryPoint] of Object.entries(config.entryPoints)) {
+		const outputFile = entryPoint.replace(/\.ts$/, ".js");
+		const fullPath = join(config.build.outDir, outputFile.replace("./", ""));
+
+		const file = Bun.file(fullPath);
+		const exists = await file.exists();
+
+		if (exists) {
+			const size = file.size;
+			const sizeKb = (size / 1024).toFixed(2);
+			console.log(`  ${GREEN}✓${NC} ${exportPath} → ${sizeKb} KB`);
+		} else {
+			console.log(`  ${RED}✗${NC} ${exportPath} → NOT FOUND`);
+		}
+	}
+
+	log.success("Build verification complete");
+}
+
+async function main() {
+	console.log(`\n${GREEN}╔══════════════════════════════════════════╗${NC}`);
+	console.log(`${GREEN}║       🔨 NUCLEUS CORE BUILD              ║${NC}`);
+	console.log(`${GREEN}╚══════════════════════════════════════════╝${NC}\n`);
+
+	const startTime = Date.now();
+
+	try {
+		log.step(1, 5, "Cleaning...");
+		await cleanDist();
+
+		log.step(2, 5, "Building JavaScript...");
+		await buildWithBun();
+
+		log.step(3, 5, "Generating Types...");
+		await generateTypes();
+
+		log.step(4, 5, "Obfuscating...");
+		await obfuscateFiles();
+		await removeSourceMaps();
+
+		log.step(5, 5, "Verifying...");
+		await verifyBuild();
+
+		const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+		console.log(`\n${GREEN}🎉 Build completed in ${elapsed}s${NC}\n`);
+	} catch (error) {
+		log.error(`Build failed: ${error}`);
+		process.exit(1);
+	}
+}
+
+main();