@zintrust/core 0.1.0

package/src/templates/project/basic/src/index.ts.tpl

@@ -0,0 +1,49 @@
+/**
+ * {{projectName}} - Zintrust Application Entry Point
+ */
+
+import { Application, Server } from '@zintrust/core';
+import { Env } from '@config/env';
+import { Logger } from '@config/logger';
+
+/**
+ * Start the application
+ */
+async function start() {
+  try {
+    // Create application instance
+    const app = Application.create();
+
+    // Boot application
+    await app.boot();
+
+    // Get port and host from environment
+    const port = Env.getInt('APP_PORT', 3000);
+    const host = Env.get('HOST', 'localhost');
+
+    // Create and start server
+    const server = Server.create(app, port, host);
+
+    // Start listening
+    await server.listen();
+
+    Logger.info(`Server running at http://${host}:${port}`);
+  } catch (error) {
+    Logger.error('Failed to start application:', error);
+    process.exit(1);
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGTERM', () => {
+  Logger.info('SIGTERM received, shutting down gracefully...');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  Logger.info('SIGINT received, shutting down gracefully...');
+  process.exit(0);
+});
+
+// Run start
+await start();

package/src/templates/project/basic/template.json

@@ -0,0 +1,17 @@
+{
+  "name": "basic",
+  "description": "Basic Zintrust project structure",
+  "directories": [
+    "app/Controllers",
+    "app/Middleware",
+    "app/Models",
+    "config",
+    "database/migrations",
+    "database/seeders",
+    "public",
+    "routes",
+    "src",
+    "tests/unit",
+    "tests/integration"
+  ]
+}

package/src/templates/project/basic/tsconfig.json.tpl

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
+    "strict": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./src/*"],
+      "@app/*": ["./app/*"],
+      "@config/*": ["./config/*"],
+      "@routes/*": ["./routes/*"],
+      "@database/*": ["./database/*"]
+    }
+  },
+  "include": ["src/**/*", "app/**/*", "routes/**/*", "database/**/*", "config/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/src/validation/ValidationError.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Validation Error
+ * Structured error response for validation failures with field-level details
+ */
+export interface FieldError {
+    field: string;
+    message: string;
+    rule: string;
+}
+export interface IValidationError extends Error {
+    errors: FieldError[];
+    toObject(): Record<string, string[]>;
+    getFieldError(field: string): string | undefined;
+    hasFieldError(field: string): boolean;
+}
+/**
+ * Convert errors array to field:errors object
+ */
+export declare const toObject: (errors: FieldError[]) => Record<string, string[]>;
+/**
+ * Get first error message for a field
+ */
+export declare const getFieldError: (errors: FieldError[], field: string) => string | undefined;
+/**
+ * Check if field has errors
+ */
+export declare const hasFieldError: (errors: FieldError[], field: string) => boolean;
+/**
+ * Create a validation error instance
+ */
+declare const createValidationError: (errors: FieldError[], message?: string) => IValidationError;
+/**
+ * ValidationError namespace - sealed for immutability
+ */
+export declare const ValidationError: Readonly<{
+    create: (errors: FieldError[], message?: string) => IValidationError;
+    toObject: (errors: FieldError[]) => Record<string, string[]>;
+    getFieldError: (errors: FieldError[], field: string) => string | undefined;
+    hasFieldError: (errors: FieldError[], field: string) => boolean;
+}>;
+export { createValidationError };
+//# sourceMappingURL=ValidationError.d.ts.map

package/src/validation/ValidationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationError.d.ts","sourceRoot":"","sources":["../../../src/validation/ValidationError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAiB,SAAQ,KAAK;IAC7C,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACrC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACjD,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CACvC;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,UAAU,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAWtE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,UAAU,EAAE,EAAE,OAAO,MAAM,KAAG,MAAM,GAAG,SAE5E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,UAAU,EAAE,EAAE,OAAO,MAAM,KAAG,OAEnE,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,qBAAqB,GACzB,QAAQ,UAAU,EAAE,EACpB,UAAS,MAA4B,KACpC,gBAQF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe;qBAflB,UAAU,EAAE,YACX,MAAM,KACd,gBAAgB;uBAjCc,UAAU,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;4BAgBlC,UAAU,EAAE,SAAS,MAAM,KAAG,MAAM,GAAG,SAAS;4BAOhD,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO;EA4BzE,CAAC;AAGH,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/src/validation/ValidationError.js

@@ -0,0 +1,53 @@
+/**
+ * Validation Error
+ * Structured error response for validation failures with field-level details
+ */
+/**
+ * Convert errors array to field:errors object
+ */
+export const toObject = (errors) => {
+    const result = {};
+    const MAX_ERRORS_PER_FIELD = 10;
+    for (const error of errors) {
+        result[error.field] ??= [];
+        if (result[error.field].length < MAX_ERRORS_PER_FIELD) {
+            result[error.field].push(error.message);
+        }
+    }
+    return result;
+};
+/**
+ * Get first error message for a field
+ */
+export const getFieldError = (errors, field) => {
+    return errors.find((e) => e.field === field)?.message;
+};
+/**
+ * Check if field has errors
+ */
+export const hasFieldError = (errors, field) => {
+    return errors.some((e) => e.field === field);
+};
+/**
+ * Create a validation error instance
+ */
+const createValidationError = (errors, message = 'Validation failed') => {
+    const error = new Error(message);
+    error.name = 'ValidationError';
+    error.errors = errors;
+    error.toObject = () => toObject(errors);
+    error.getFieldError = (field) => getFieldError(errors, field);
+    error.hasFieldError = (field) => hasFieldError(errors, field);
+    return error;
+};
+/**
+ * ValidationError namespace - sealed for immutability
+ */
+export const ValidationError = Object.freeze({
+    create: createValidationError,
+    toObject,
+    getFieldError,
+    hasFieldError,
+});
+// For backward compatibility with existing imports
+export { createValidationError };

package/src/validation/Validator.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Validator
+ * Schema-based input validation with fluent API matching QueryBuilder style
+ * Sealed namespace pattern - all exports through Validator namespace
+ */
+export type Rule = 'required' | 'email' | 'string' | 'number' | 'boolean' | 'array' | 'integer' | 'min' | 'max' | 'minLength' | 'maxLength' | 'regex' | 'in' | 'custom';
+export interface ValidationRule {
+    rule: Rule;
+    value?: unknown;
+    message?: string;
+}
+export interface ISchema {
+    required(field: string, message?: string): ISchema;
+    string(field: string, message?: string): ISchema;
+    number(field: string, message?: string): ISchema;
+    integer(field: string, message?: string): ISchema;
+    boolean(field: string, message?: string): ISchema;
+    array(field: string, message?: string): ISchema;
+    email(field: string, message?: string): ISchema;
+    min(field: string, value: number, message?: string): ISchema;
+    max(field: string, value: number, message?: string): ISchema;
+    minLength(field: string, value: number, message?: string): ISchema;
+    maxLength(field: string, value: number, message?: string): ISchema;
+    regex(field: string, pattern: RegExp, message?: string): ISchema;
+    in(field: string, values: unknown[], message?: string): ISchema;
+    custom(field: string, validator: (value: unknown) => boolean, message?: string): ISchema;
+    getRules(): Map<string, ValidationRule[]>;
+}
+export interface SchemaType {
+    create(): ISchema;
+}
+/**
+ * Schema builder for defining validation rules
+ * Sealed namespace for immutability
+ */
+export declare const Schema: Readonly<{
+    /**
+     * Create a new schema instance
+     */
+    create(): ISchema;
+}>;
+/**
+ * Validator validates data against a schema
+ */
+export declare const Validator: Readonly<{
+    Schema: Readonly<{
+        /**
+         * Create a new schema instance
+         */
+        create(): ISchema;
+    }>;
+    validate: (data: Record<string, unknown>, schema: ISchema) => Record<string, unknown>;
+    isValid: (data: Record<string, unknown>, schema: ISchema) => boolean;
+}>;
+/**
+ * Export ValidationError for use in tests and applications
+ */
+export { ValidationError } from './ValidationError';
+export type { FieldError } from './ValidationError';
+//# sourceMappingURL=Validator.d.ts.map

package/src/validation/Validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../../src/validation/Validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,MAAM,IAAI,GACZ,UAAU,GACV,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,OAAO,GACP,SAAS,GACT,KAAK,GACL,KAAK,GACL,WAAW,GACX,WAAW,GACX,OAAO,GACP,IAAI,GACJ,QAAQ,CAAC;AAEb,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAClD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAClD,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChD,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7D,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7D,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACzF,QAAQ,IAAI,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;CAC3C;AA2BD,MAAM,WAAW,UAAU;IACzB,MAAM,IAAI,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM;IACjB;;OAEG;cACO,OAAO;EAuBjB,CAAC;AA4LH;;GAEG;AAEH,eAAO,MAAM,SAAS;;QA1NpB;;WAEG;kBACO,OAAO;;qBA4BK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;oBAyBnE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,OAAO,KAAG,OAAO;EAsKvE,CAAC;AAEH;;GAEG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,YAAY,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC"}

package/src/validation/Validator.js

@@ -0,0 +1,190 @@
+/**
+ * Validator
+ * Schema-based input validation with fluent API matching QueryBuilder style
+ * Sealed namespace pattern - all exports through Validator namespace
+ */
+import { Logger } from '../config/logger';
+import { createValidationError } from './ValidationError';
+const addSimpleRule = (schema, rules, field, rule, message) => {
+    if (!rules.has(field))
+        rules.set(field, []);
+    rules.get(field)?.push({ rule, message });
+    return schema;
+};
+const addComplexRule = (schema, rules, field, rule, value, message) => {
+    if (!rules.has(field))
+        rules.set(field, []);
+    rules.get(field)?.push({ rule, value, message });
+    return schema;
+};
+/**
+ * Schema builder for defining validation rules
+ * Sealed namespace for immutability
+ */
+export const Schema = Object.freeze({
+    /**
+     * Create a new schema instance
+     */
+    create() {
+        const rules = new Map();
+        const schema = {
+            required: (f, m) => addSimpleRule(schema, rules, f, 'required', m),
+            string: (f, m) => addSimpleRule(schema, rules, f, 'string', m),
+            number: (f, m) => addSimpleRule(schema, rules, f, 'number', m),
+            integer: (f, m) => addSimpleRule(schema, rules, f, 'integer', m),
+            boolean: (f, m) => addSimpleRule(schema, rules, f, 'boolean', m),
+            array: (f, m) => addSimpleRule(schema, rules, f, 'array', m),
+            email: (f, m) => addSimpleRule(schema, rules, f, 'email', m),
+            min: (f, v, m) => addComplexRule(schema, rules, f, 'min', v, m),
+            max: (f, v, m) => addComplexRule(schema, rules, f, 'max', v, m),
+            minLength: (f, v, m) => addComplexRule(schema, rules, f, 'minLength', v, m),
+            maxLength: (f, v, m) => addComplexRule(schema, rules, f, 'maxLength', v, m),
+            regex: (f, p, m) => addComplexRule(schema, rules, f, 'regex', p, m),
+            in: (f, v, m) => addComplexRule(schema, rules, f, 'in', v, m),
+            custom: (f, v, m) => addComplexRule(schema, rules, f, 'custom', v, m),
+            getRules: () => rules,
+        };
+        return schema;
+    },
+});
+/**
+ * Validate data against schema
+ */
+const validate = (data, schema) => {
+    const errors = [];
+    const rules = schema.getRules();
+    for (const [field, fieldRules] of rules.entries()) {
+        const value = data[field];
+        for (const rule of fieldRules) {
+            const error = validateRule(field, value, rule);
+            if (error !== null) {
+                errors.push(error);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw createValidationError(errors);
+    }
+    return data;
+};
+/**
+ * Check if data is valid without throwing
+ */
+const isValid = (data, schema) => {
+    try {
+        validate(data, schema);
+        return true;
+    }
+    catch (error) {
+        Logger.error('Validation failed', error);
+        return false;
+    }
+};
+function validateRule(field, value, rule) {
+    const message = (rule?.message ?? '') || getDefaultMessage(field, rule.rule);
+    const validators = {
+        required: () => validateRequired(field, value, message),
+        string: () => validateString(field, value, message),
+        number: () => validateNumber(field, value, message),
+        integer: () => validateInteger(field, value, message),
+        boolean: () => validateBoolean(field, value, message),
+        array: () => validateArray(field, value, message),
+        email: () => validateEmail(field, value, message),
+        min: () => validateMin(field, value, rule.value, message),
+        max: () => validateMax(field, value, rule.value, message),
+        minLength: () => validateMinLength(field, value, rule.value, message),
+        maxLength: () => validateMaxLength(field, value, rule.value, message),
+        regex: () => validateRegex(field, value, rule.value, message),
+        in: () => validateIn(field, value, rule.value, message),
+        custom: () => validateCustom(field, value, rule.value, message),
+    };
+    return validators[rule.rule]?.() ?? null;
+}
+function validateRequired(field, value, message) {
+    return value === null || value === undefined || value === ''
+        ? { field, message, rule: 'required' }
+        : null;
+}
+function validateString(field, value, message) {
+    return typeof value === 'string' ? null : { field, message, rule: 'string' };
+}
+function validateNumber(field, value, message) {
+    return typeof value !== 'number' || Number.isNaN(value)
+        ? { field, message, rule: 'number' }
+        : null;
+}
+function validateInteger(field, value, message) {
+    return Number.isInteger(value) ? null : { field, message, rule: 'integer' };
+}
+function validateBoolean(field, value, message) {
+    return typeof value === 'boolean' ? null : { field, message, rule: 'boolean' };
+}
+function validateArray(field, value, message) {
+    return Array.isArray(value) ? null : { field, message, rule: 'array' };
+}
+function validateEmail(field, value, message) {
+    // Sonar S5852: Use a safe regex that avoids backtracking by excluding dots from domain labels
+    const emailRegex = /^[^\s@]+@[^\s@.]+(\.[^\s@.]+)+$/;
+    return typeof value !== 'string' || !emailRegex.test(value)
+        ? { field, message, rule: 'email' }
+        : null;
+}
+function validateMin(field, value, minValue, message) {
+    return typeof value === 'number' && value < minValue ? { field, message, rule: 'min' } : null;
+}
+function validateMax(field, value, maxValue, message) {
+    return typeof value === 'number' && value > maxValue ? { field, message, rule: 'max' } : null;
+}
+function validateMinLength(field, value, minLen, message) {
+    return (typeof value === 'string' || Array.isArray(value)) && value.length < minLen
+        ? { field, message, rule: 'minLength' }
+        : null;
+}
+function validateMaxLength(field, value, maxLen, message) {
+    return (typeof value === 'string' || Array.isArray(value)) && value.length > maxLen
+        ? { field, message, rule: 'maxLength' }
+        : null;
+}
+function validateRegex(field, value, pattern, message) {
+    return typeof value !== 'string' || !pattern.test(value)
+        ? { field, message, rule: 'regex' }
+        : null;
+}
+function validateIn(field, value, values, message) {
+    return values.includes(value) ? null : { field, message, rule: 'in' };
+}
+function validateCustom(field, value, validator, message) {
+    return validator(value) ? null : { field, message, rule: 'custom' };
+}
+function getDefaultMessage(field, rule) {
+    const messages = {
+        required: `${field} is required`,
+        email: `${field} must be a valid email`,
+        string: `${field} must be a string`,
+        number: `${field} must be a number`,
+        boolean: `${field} must be a boolean`,
+        array: `${field} must be an array`,
+        integer: `${field} must be an integer`,
+        min: `${field} is too small`,
+        max: `${field} is too large`,
+        minLength: `${field} is too short`,
+        maxLength: `${field} is too long`,
+        regex: `${field} format is invalid`,
+        in: `${field} value is not allowed`,
+        custom: `${field} validation failed`,
+    };
+    return messages[rule];
+}
+/**
+ * Validator validates data against a schema
+ */
+// Sealed namespace with validation functionality
+export const Validator = Object.freeze({
+    Schema,
+    validate,
+    isValid,
+});
+/**
+ * Export ValidationError for use in tests and applications
+ */
+export { ValidationError } from './ValidationError';