nucleus-core-ts 0.8.0

package/dist/src/types.d.ts

@@ -0,0 +1,588 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: <drizzle column builders are complex> */
+import type { Algorithm } from "src/Services";
+export type SystemTableFeatureSets = "authentication" | "authorization" | "audit" | "notification" | "verification";
+export type GenericNucleusMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "TOGGLE" | "VERIFICATION";
+export type NucleusColumnType = "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";
+export type NucleusFKAction = "cascade" | "restrict" | "no action" | "set null" | "set default";
+export type NucleusIndexMethod = "btree" | "hash" | "gist" | "spgist" | "gin" | "brin";
+export type NucleusColumnMode = "string" | "date" | "json" | "number";
+export interface NucleusColumnReference {
+    table: string;
+    column?: string;
+    onDelete?: NucleusFKAction;
+    onUpdate?: NucleusFKAction;
+}
+export interface NucleusColumnEnum {
+    name: string;
+    values: string[];
+}
+export interface NucleusColumnValidation {
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    format?: "email" | "url" | "uuid" | "date" | "datetime" | "time" | "uri" | "ipv4" | "ipv6";
+    customMessage?: string;
+}
+export type NucleusSanitizeOption = "trim" | "lowercase" | "uppercase" | "escapeHtml" | "stripTags" | "normalizeEmail" | "toNumber" | "toBoolean" | "slugify";
+export interface NucleusColumn {
+    name: string;
+    type: NucleusColumnType;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    dimensions?: number;
+    mode?: NucleusColumnMode;
+    withTimezone?: boolean;
+    nullable?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    primaryKey?: boolean;
+    default?: unknown;
+    defaultRaw?: string;
+    references?: NucleusColumnReference;
+    array?: boolean;
+    arrayDimensions?: number;
+    enumValues?: string[];
+    enum?: NucleusColumnEnum;
+    generatedAlwaysAs?: string;
+    generatedAlwaysAsIdentity?: boolean;
+    generatedByDefaultAsIdentity?: boolean;
+    check?: string;
+    comment?: string;
+    validation?: NucleusColumnValidation;
+    sanitize?: NucleusSanitizeOption[];
+}
+export interface NucleusIndex {
+    name?: string;
+    columns: string[];
+    unique?: boolean;
+    using?: NucleusIndexMethod;
+    where?: string;
+    concurrently?: boolean;
+}
+export interface NucleusUniqueConstraint {
+    name?: string;
+    columns: string[];
+}
+export interface NucleusCheckConstraint {
+    name?: string;
+    expression: string;
+}
+export interface NucleusConstraints {
+    primaryKey?: string[];
+    unique?: NucleusUniqueConstraint[];
+    check?: NucleusCheckConstraint[];
+}
+export interface NucleusTable {
+    table_name: string;
+    feature_set?: SystemTableFeatureSets[];
+    add_base_columns?: boolean;
+    is_form_data?: boolean;
+    available_app_ids?: string[];
+    available_schemas?: string[];
+    excluded_schemas?: string[];
+    excluded_methods?: GenericNucleusMethods[];
+    is_public?: Partial<Record<GenericNucleusMethods, boolean>>;
+    columns?: NucleusColumn[];
+    indexes?: NucleusIndex[];
+    constraints?: NucleusConstraints;
+    group_name?: string;
+    bulk_endpoints_enabled?: boolean;
+}
+export type NucleusConfigProps = {
+    options: NucleusConfigOptions;
+    targetSchema?: string;
+};
+export interface NucleusConfigOptions {
+    appId: string;
+    mode?: "development" | "production";
+    database: {
+        url?: string;
+        type?: "postgres";
+        isMultiTenant?: boolean;
+        schemas?: string[];
+        allowDataLoss?: boolean;
+    };
+    redis: {
+        url?: string;
+        host?: string;
+        port?: number;
+        withDapr?: boolean;
+        stateStoreName?: string;
+    };
+    authentication?: {
+        enabled?: boolean;
+        passwordPolicy?: {
+            minLength?: number;
+            maxLength?: number;
+            requireUppercase?: boolean;
+            requireLowercase?: boolean;
+            requireNumber?: boolean;
+            requireSpecialChar?: boolean;
+            specialChars?: string;
+            preventCommonPasswords?: boolean;
+            preventUserInfoInPassword?: boolean;
+            showStrengthIndicator?: boolean;
+        };
+        accessToken?: {
+            secret?: string;
+            expiresIn?: string;
+            algorithm?: Algorithm;
+            issuer?: string;
+            audience?: string;
+            name?: string;
+            setHeadersEnabled?: boolean;
+            returnJson?: boolean;
+        };
+        refreshToken?: {
+            secret?: string;
+            expiresIn?: string;
+            algorithm?: Algorithm;
+            issuer?: string;
+            audience?: string;
+            name?: string;
+            setHeadersEnabled?: boolean;
+            returnJson?: boolean;
+        };
+        sessionToken?: {
+            secret?: string;
+            expiresIn?: string;
+            algorithm?: Algorithm;
+            issuer?: string;
+            audience?: string;
+            name?: string;
+            setHeadersEnabled?: boolean;
+            returnJson?: boolean;
+        };
+        login?: {
+            route?: string;
+            rememberMe: boolean;
+            isPublic: boolean;
+            enabled: boolean;
+            redirectUrl?: string;
+            captcha?: {
+                enabled?: boolean;
+            };
+        };
+        register?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+            showFirstName?: boolean;
+            showLastName?: boolean;
+            createProfileOnRegister?: boolean;
+            termsUrl?: string;
+            privacyUrl?: string;
+            emailVerification?: {
+                enabled?: boolean;
+                provider?: "gmail";
+                tokenExpiresIn?: string;
+                redirectUrl?: string;
+                resendCooldown?: string;
+                maxResendAttempts?: number;
+                templates?: {
+                    verification?: {
+                        subject?: string;
+                        htmlTemplatePath?: string;
+                    };
+                    welcome?: {
+                        enabled?: boolean;
+                        subject?: string;
+                        htmlTemplatePath?: string;
+                    };
+                };
+            };
+        };
+        logout?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+        };
+        refresh?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+        };
+        passwordReset?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+            redirectUrl?: string;
+        };
+        passwordChange?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+        };
+        passwordSet?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+        };
+        sessions?: {
+            route?: string;
+            isPublic: boolean;
+            enabled: boolean;
+            maxActiveSessions?: number;
+            inactivityTimeout?: string;
+            allowMultipleDevices?: boolean;
+            trustNewDevices?: boolean;
+            notifyOnNewDevice?: boolean;
+            approvalRedirectUrl?: string;
+        };
+        magicLink?: {
+            route?: string;
+            verifyRoute?: string;
+            isPublic: boolean;
+            enabled: boolean;
+            expiresIn?: string;
+            redirectUrl?: string;
+        };
+        me?: {
+            route?: string;
+            isPublic?: boolean;
+            enabled?: boolean;
+            includeProfile?: boolean;
+            includeAddresses?: boolean;
+            includePhones?: boolean;
+            includeFiles?: boolean;
+            includeRoles?: boolean;
+        };
+        invite?: {
+            route?: string;
+            isPublic?: boolean;
+            enabled: boolean;
+            tokenExpiresIn?: string;
+            redirectUrl?: string;
+        };
+        emailVerification?: {
+            route?: string;
+            resendRoute?: string;
+            isPublic?: boolean;
+            enabled: boolean;
+        };
+        captcha?: {
+            route?: string;
+            isPublic?: boolean;
+            enabled: boolean;
+            type?: "math" | "image" | "puzzle" | "text";
+            difficulty?: "easy" | "medium" | "hard";
+            expiresIn?: string;
+            maxAttempts?: number;
+            caseSensitive?: boolean;
+            rateLimit?: {
+                maxGeneratePerMinute?: number;
+                maxGeneratePerHour?: number;
+            };
+        };
+    };
+    verification?: {
+        enabled?: boolean;
+        autoResetOnRejection?: boolean;
+        requireSignatureByDefault?: boolean;
+        diffTrackingEnabled?: boolean;
+        endpoints?: {
+            enabled?: boolean;
+            basePath?: string;
+        };
+    };
+    notification?: {
+        enabled?: boolean;
+        portalEnabled?: boolean;
+        emailEnabled?: boolean;
+        defaultChannel?: "portal" | "email" | "both";
+        templateVariables?: Record<string, string>;
+    };
+    authorization?: {
+        enabled?: boolean;
+        autoSeedClaims?: boolean;
+        skipTables?: string[];
+        skipColumns?: string[];
+        excludedPaths?: string[];
+        publicPaths?: string[];
+        godminEmail?: string;
+        godminPassword?: string;
+    };
+    audit?: {
+        enabled?: boolean;
+        actions?: {
+            GET?: boolean;
+            INSERT?: boolean;
+            UPDATE?: boolean;
+            DELETE?: boolean;
+            TOGGLE?: boolean;
+            VERIFICATION?: boolean;
+        };
+    };
+    entities: NucleusTable[];
+    rateLimit?: {
+        enabled?: boolean;
+        strategy?: "sliding-window" | "fixed-window" | "token-bucket";
+        keyPrefix?: string;
+        authRoutes?: {
+            window?: string;
+            max?: number;
+            login?: {
+                window?: string;
+                max?: number;
+                blockDuration?: string;
+            };
+            register?: {
+                window?: string;
+                max?: number;
+                blockDuration?: string;
+            };
+            passwordReset?: {
+                window?: string;
+                max?: number;
+                blockDuration?: string;
+            };
+            magicLink?: {
+                window?: string;
+                max?: number;
+                blockDuration?: string;
+            };
+        };
+        publicRoutes?: {
+            window?: string;
+            max?: number;
+        };
+        privateRoutes?: {
+            window?: string;
+            max?: number;
+        };
+        byIp?: boolean;
+        byUserId?: boolean;
+        byEndpoint?: boolean;
+        skipSuccessfulRequests?: boolean;
+        headers?: {
+            remaining?: string;
+            reset?: string;
+            limit?: string;
+        };
+        whitelist?: string[];
+        blacklist?: string[];
+    };
+    monitoring?: {
+        enabled?: boolean;
+        system?: {
+            enabled?: boolean;
+            collectInterval?: string;
+            metrics?: {
+                cpu?: boolean;
+                memory?: boolean;
+                disk?: boolean;
+                network?: boolean;
+                process?: boolean;
+            };
+        };
+        application?: {
+            enabled?: boolean;
+            metrics?: {
+                requests?: boolean;
+                responseTime?: boolean;
+                errors?: boolean;
+                rateLimits?: boolean;
+            };
+        };
+        database?: {
+            enabled?: boolean;
+            metrics?: {
+                connections?: boolean;
+                queryTime?: boolean;
+                slowQueryThreshold?: string;
+            };
+        };
+        redis?: {
+            enabled?: boolean;
+        };
+        persistence?: {
+            enabled?: boolean;
+            flushInterval?: string;
+            retentionDays?: number;
+        };
+        alerts?: {
+            enabled?: boolean;
+            email?: {
+                enabled?: boolean;
+                recipients?: string[];
+            };
+            thresholds?: {
+                cpuPercent?: number;
+                memoryPercent?: number;
+                diskPercent?: number;
+                errorRatePercent?: number;
+                responseTimeMs?: number;
+                rateLimitBlocksPerMinute?: number;
+            };
+            cooldown?: string;
+        };
+        endpoints?: {
+            enabled?: boolean;
+            basePath?: string;
+            stream?: {
+                enabled?: boolean;
+                path?: string;
+                interval?: string;
+            };
+            snapshot?: {
+                enabled?: boolean;
+                path?: string;
+            };
+            history?: {
+                enabled?: boolean;
+                path?: string;
+                maxMinutes?: number;
+            };
+            alerts?: {
+                enabled?: boolean;
+                path?: string;
+            };
+        };
+    };
+    email?: {
+        gmail?: {
+            enabled?: boolean;
+            json_file_path?: string;
+            from_email?: string;
+            from_name?: string;
+        };
+    };
+    storage?: {
+        enabled?: boolean;
+        basePath?: string;
+        maxFileSizeBytes?: number;
+        allowedMimeTypes?: string[];
+        blockedMimeTypes?: string[];
+        cdn?: {
+            enabled?: boolean;
+            basePath?: string;
+            cacheMaxAge?: number;
+            enableRangeRequests?: boolean;
+            enableEtag?: boolean;
+            corsOrigins?: string[];
+        };
+        formData?: {
+            filesField?: string;
+            dataField?: string;
+            maxFiles?: number;
+        };
+    };
+}
+export type SchemaTableRegistry = Record<string, any>;
+export type StandardReturn<T> = {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: Error | string;
+};
+export type SortDirection = "asc" | "desc";
+export type FilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "like" | "ilike" | "in" | "notIn" | "isNull" | "isNotNull";
+export interface FilterCondition {
+    field: string;
+    operator: FilterOperator;
+    value: unknown;
+}
+export interface SortCondition {
+    field: string;
+    direction: SortDirection;
+}
+export interface RelationQuery {
+    name: string;
+    columns?: string[];
+    where?: FilterCondition[];
+    limit?: number;
+    with?: RelationQuery[];
+}
+export interface StandardQueryParams {
+    page?: number;
+    limit?: number;
+    offset?: number;
+    search?: string;
+    searchFields?: string[];
+    filters?: FilterCondition[];
+    sort?: SortCondition[];
+    select?: string[];
+    with?: RelationQuery[];
+    distinct?: boolean;
+    distinctOn?: string[];
+}
+export interface PaginationMeta {
+    page: number;
+    limit: number;
+    offset: number;
+    totalItems: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    nextPage: number | null;
+    prevPage: number | null;
+}
+export interface PaginatedResult<T> {
+    items: T[];
+    meta: PaginationMeta;
+}
+export type PaginatedReturn<T> = StandardReturn<PaginatedResult<T>>;
+export type Tokens = "access_token" | "refresh_token" | "session_token";
+export type TokenNames = Record<Tokens, string>;
+export type TokenValues = Record<Tokens, string | undefined>;
+export type AuditPayload<T = unknown> = {
+    id: string;
+    user_id: string;
+    entity_name: string;
+    entity_id: string | null;
+    operation_type: string;
+    summary: string;
+    old_values: Record<string, T>;
+    new_values: Record<string, T>;
+    ip_address: string;
+    user_agent: string;
+    timestamp: string;
+    path: string;
+    query: string;
+};
+export interface NucleusSwaggerConfig {
+    enabled?: boolean;
+    path?: string;
+    provider?: "scalar" | "swagger-ui";
+    documentation?: {
+        info?: {
+            title?: string;
+            description?: string;
+            version?: string;
+            contact?: {
+                name?: string;
+                email?: string;
+                url?: string;
+            };
+            license?: {
+                name?: string;
+                url?: string;
+            };
+        };
+        tags?: Array<{
+            name: string;
+            description?: string;
+        }>;
+        servers?: Array<{
+            url: string;
+            description?: string;
+        }>;
+    };
+    exclude?: (string | RegExp)[];
+    excludeStaticFile?: boolean;
+    scalarConfig?: Record<string, unknown>;
+}
+export interface NucleusElysiaPluginConfig {
+    options: NucleusConfigOptions | string;
+    schema: string;
+    relations: string;
+    targetSchemas?: string[];
+    swagger?: NucleusSwaggerConfig;
+    systemTables?: NucleusTable[];
+    /** Static assets path or false to disable. Defaults to `${process.cwd()}/public` */
+    staticAssets?: string | false;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,99 @@
+{
+	"name": "nucleus-core-ts",
+	"version": "0.8.0",
+	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
+	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
+	"license": "SEE LICENSE IN LICENSE",
+	"keywords": [
+		"backend",
+		"framework",
+		"elysia",
+		"drizzle",
+		"typescript"
+	],
+	"files": [
+		"dist",
+		"schemas",
+		"scripts",
+		"src/system.tables.json",
+		"public",
+		"LICENSE"
+	],
+	"module": "dist/index.js",
+	"type": "module",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./client": {
+			"types": "./dist/client.d.ts",
+			"import": "./dist/client.js"
+		},
+		"./fe": {
+			"types": "./dist/fe/index.d.ts",
+			"import": "./dist/fe/index.js"
+		},
+		"./proxy": {
+			"types": "./dist/src/Client/Proxy/index.d.ts",
+			"import": "./dist/src/Client/Proxy/index.js"
+		}
+	},
+	"scripts": {
+		"build": "bun run scripts/build.ts",
+		"build:quick": "bun run build:js && bun run build:types",
+		"build:js": "bun build ./index.ts ./client.ts ./fe/index.ts ./src/Client/Proxy/index.ts --outdir=dist --target=bun --format=esm --splitting --minify --external react --external react-dom --external gsap --external @gsap/react --external h-state --external three --external @react-three/fiber --external elysia --external drizzle-orm --external drizzle-kit --external ioredis --external googleapis --external @dapr/dapr --external pg",
+		"build:types": "tsc --declaration --emitDeclarationOnly --outDir dist --skipLibCheck",
+		"version:patch": "bun run scripts/version.ts patch",
+		"version:minor": "bun run scripts/version.ts minor",
+		"version:major": "bun run scripts/version.ts major",
+		"publish:npm": "bun run scripts/publish.ts",
+		"publish:dry": "bun run scripts/publish.ts --dry-run",
+		"release": "bun run version:patch && bun run build && bun run publish:npm",
+		"release:minor": "bun run version:minor && bun run build && bun run publish:npm",
+		"release:major": "bun run version:major && bun run build && bun run publish:npm",
+		"generate:schemas": "bun run scripts/generate-types-schema.ts",
+		"lint": "biome check . --write",
+		"prepublishOnly": "echo 'Use: bun run publish:npm'"
+	},
+	"bin": {
+		"nucleus-generate": "./scripts/generate-schema.ts"
+	},
+	"devDependencies": {
+		"@react-three/fiber": "latest",
+		"@types/bun": "latest",
+		"@types/pg": "latest",
+		"@types/react": "latest",
+		"@types/react-dom": "latest",
+		"@types/three": "latest",
+		"bun-plugin-tailwind": "latest",
+		"drizzle-kit": "latest",
+		"javascript-obfuscator": "^4.1.1",
+		"lucide-react": "latest",
+		"three": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "latest",
+		"elysia": "latest",
+		"@dapr/dapr": "latest",
+		"react": "latest",
+		"react-dom": "latest",
+		"pg": "latest",
+		"tailwindcss": "latest",
+		"tailwind-merge": "latest",
+		"clsx": "latest"
+	},
+	"dependencies": {
+		"@elysiajs/static": "latest",
+		"@elysiajs/swagger": "latest",
+		"@gsap/react": "latest",
+		"add": "latest",
+		"bun": "latest",
+		"drizzle-orm": "latest",
+		"googleapis": "latest",
+		"gsap": "latest",
+		"h-state": "latest",
+		"ioredis": "latest"
+	}
+}

package/public/components/CTA.tsx

@@ -0,0 +1,25 @@
+export function CTA() {
+	return (
+		<section className="cta">
+			<div className="container">
+				<div className="cta-inner">
+					<div className="cta-content">
+						<h2 className="cta-title">Ready to Build Something Great?</h2>
+						<p className="cta-description">
+							Get started with Nucleus Core today. Full documentation, examples,
+							and community support included.
+						</p>
+						<div className="cta-actions">
+							<a href="/docs" className="btn btn-primary">
+								Read the Documentation
+							</a>
+							<a href="https://github.com" className="btn btn-secondary">
+								View on GitHub
+							</a>
+						</div>
+					</div>
+				</div>
+			</div>
+		</section>
+	);
+}