@harperfast/harper-pro 5.0.30 → 5.1.0-beta.2

package/core/utility/packageUtils.js

@@ -1,3 +1,4 @@
+'use strict';
 const { join, dirname } = require('node:path');
 const { existsSync, readFileSync } = require('node:fs');
 
@@ -6,9 +7,6 @@ const { existsSync, readFileSync } = require('node:fs');
  * subsequently the root directory of the package. In theory we could require
  * package.json directly (`require('../../package.json')`), but that would not
  * give us the root directory of the repo, which is needed for other things.
- * Furthermore, when this is eventually converted to TS, we should consider
- * using `import('../../package.json')` as that will give type-safe access to
- * the package.json file.
  *
  * The purpose of doing this instead of cobbling together a path directly is
  * that in development mode this file will be resolved from its actual path
@@ -18,13 +16,11 @@ const { existsSync, readFileSync } = require('node:fs');
  * requires/imports), we need to stick to directory traversal to find the
  * package root.
  *
- * This function isn't full-proof and could fail in some edge cases. The max
- * iteration check is in place to prevent infinite loops.
- *
- * If we ever encounter this error, we should improve the function to handle
- * the edge case instead of just increasing the `MAX` value.
- *
- * @returns {string} package.json file path
+ * NOTE: This file is intentionally kept as CommonJS (.js) rather than
+ * TypeScript. Node v24 type-stripping treats `.ts` files with top-level
+ * `import`/`export` as ESM, where `__dirname` is undefined. Keeping this as
+ * `.js` lets it stay CJS, retaining `__dirname`, while remaining importable
+ * from both CJS and ESM (via Node's CJS interop) consumers.
  */
 function findPackageJson() {
 	const MAX = 10;
@@ -44,12 +40,7 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
  * The Harper package root directory.
  *
  * Works across dev and prod (built).
- *
- * @type {string}
  */
 const PACKAGE_ROOT = dirname(packageJsonPath);
 
-module.exports = {
-	packageJson,
-	PACKAGE_ROOT,
-};
+module.exports = { packageJson, PACKAGE_ROOT };

package/core/utility/password.ts

@@ -1,6 +1,6 @@
 import * as crypto from 'node:crypto';
 import * as argon2 from 'argon2';
-import { get } from './environment/environmentManager.js';
+import { get } from './environment/environmentManager.ts';
 import { CONFIG_PARAMS } from './hdbTerms.ts';
 const configuredHashFunction = get(CONFIG_PARAMS.AUTHENTICATION_HASHFUNCTION)?.toLowerCase();
 

package/core/utility/processManagement/processManagement.js

@@ -2,8 +2,8 @@
 
 const hdbTerms = require('../hdbTerms.ts');
 const servicesConfig = require('./servicesConfig.js');
-const envMangr = require('../environment/environmentManager.js');
-const hdbLogger = require('../../utility/logging/harper_logger.js');
+const envMangr = require('../environment/environmentManager.ts');
+const hdbLogger = require('../../utility/logging/harper_logger.ts');
 const { onMessageFromWorkers } = require('../../server/threads/manageThreads.js');
 const fs = require('fs');
 const path = require('node:path');

package/core/utility/processManagement/servicesConfig.js

@@ -3,7 +3,7 @@
 const hdbTerms = require('../hdbTerms.ts');
 const path = require('path');
 const { PACKAGE_ROOT } = require('../../utility/packageUtils.js');
-const hdbUtils = require('../common_utils.js');
+const hdbUtils = require('../common_utils.ts');
 const SCRIPTS_DIR = path.join(PACKAGE_ROOT, 'utility/scripts');
 const RESTART_SCRIPT = path.join(SCRIPTS_DIR, hdbTerms.HDB_RESTART_SCRIPT);
 

package/core/utility/{signalling.js → signalling.ts}

@@ -1,12 +1,12 @@
 'use strict';
 
-const hdbTerms = require('./hdbTerms.ts');
-const hdbLogger = require('../utility/logging/harper_logger.js');
-const ITCEventObject = require('../server/itc/utility/ITCEventObject.js');
+import * as hdbTerms from './hdbTerms.ts';
+import hdbLogger from '../utility/logging/harper_logger.ts';
+import ITCEventObject from '../server/itc/utility/ITCEventObject.js';
 let serverItcHandlers;
-const { sendItcEvent } = require('../server/threads/itc.js');
+import { sendItcEvent } from '../server/threads/itc.js';
 
-function signalSchemaChange(message) {
+export function signalSchemaChange(message: any) {
 	try {
 		hdbLogger.debug('signalSchemaChange called with message:', message);
 		serverItcHandlers = serverItcHandlers || require('../server/itc/serverHandlers.js');
@@ -18,7 +18,7 @@ function signalSchemaChange(message) {
 	}
 }
 
-function signalUserChange(message) {
+export function signalUserChange(message: any) {
 	try {
 		hdbLogger.trace('signalUserChange called with message:', message);
 		serverItcHandlers = serverItcHandlers || require('../server/itc/serverHandlers.js');
@@ -29,8 +29,3 @@ function signalUserChange(message) {
 		hdbLogger.error(err);
 	}
 }
-
-module.exports = {
-	signalSchemaChange,
-	signalUserChange,
-};

package/core/utility/watcherFallback.ts

@@ -0,0 +1,74 @@
+// Polling fallback for chokidar watchers.
+//
+// When the host system runs out of inotify watches (ENOSPC) or file descriptors
+// (EMFILE), native chokidar watchers emit an error and stop firing change
+// events. Polling-based watching doesn't consume inotify handles or per-watcher
+// file descriptors, so we fall back to it once and warn — see harper#488.
+
+import { loggerWithTag } from './logging/harper_logger.ts';
+
+// One-time process-wide warning so a thundering herd of failing watchers doesn't
+// produce hundreds of identical log lines.
+let exhaustionWarned = false;
+
+const fallbackLogger = loggerWithTag('watcher');
+
+/**
+ * Returns `true` if the chokidar error indicates the OS-level watcher pool is
+ * exhausted (inotify watches on Linux, open file descriptors on macOS/Linux).
+ */
+export function isWatcherExhaustionError(error: unknown): boolean {
+	if (typeof error !== 'object' || error === null) return false;
+	const code = (error as { code?: string }).code;
+	return code === 'ENOSPC' || code === 'EMFILE';
+}
+
+/**
+ * Polling-watch options to pass through to chokidar when falling back, for
+ * watchers backed by a single file (a config.yaml etc.).
+ *
+ * Intervals are deliberately conservative — polling-based watching is
+ * fundamentally less efficient than inotify, and once we're in this mode the
+ * host is already under resource pressure. A second-scale interval keeps CPU
+ * cost bounded; the alternative is to lose change events entirely.
+ */
+export const POLLING_FALLBACK_OPTIONS = {
+	usePolling: true,
+	interval: 1000,
+	binaryInterval: 2000,
+} as const;
+
+/**
+ * Polling-watch options for directory-tree watchers (EntryHandler). Chokidar
+ * polls fs.stat on every watched file each interval, so a tree with thousands
+ * of files at 1s would burn meaningful CPU; we trade responsiveness for cost
+ * here on the assumption that the host is already strained.
+ */
+export const DIRECTORY_POLLING_FALLBACK_OPTIONS = {
+	usePolling: true,
+	interval: 3000,
+	binaryInterval: 5000,
+} as const;
+
+/**
+ * Log a one-time warning when a watcher first falls back to polling. Subsequent
+ * fallbacks in the same process are silent.
+ */
+export function warnWatcherFallback(watchedPath: string): void {
+	if (exhaustionWarned) return;
+	exhaustionWarned = true;
+	fallbackLogger.warn?.(
+		`File watcher exhaustion (ENOSPC/EMFILE) on ${watchedPath}. ` +
+			'Falling back to polling-based watching for affected watchers — ' +
+			'this will increase CPU usage proportional to the size of the watched trees ' +
+			'and may delay or miss rapid file changes. ' +
+			'To restore native watching, raise the OS limit, for example: ' +
+			'`sudo sysctl -w fs.inotify.max_user_watches=524288` ' +
+			'or `sudo sysctl -w fs.inotify.max_user_instances=10000` (Linux).'
+	);
+}
+
+// Test-only hook to reset the one-time warning gate between cases.
+export function _resetForTests(): void {
+	exhaustionWarned = false;
+}

package/core/validation/analyticsValidator.ts

@@ -0,0 +1,44 @@
+import Joi from 'joi';
+import * as validator from './validationWrapper.ts';
+import { COMPARATORS } from '../resources/ResourceInterface.ts';
+
+// A leaf condition. Both the canonical (attribute/comparator/value) and the
+// legacy (search_attribute/search_type/search_value) names are accepted —
+// `conformCondition` in resources/analytics/read.ts maps the latter onto the
+// former.
+const directConditionSchema = Joi.object({
+	attribute: Joi.string(),
+	search_attribute: Joi.string(),
+	comparator: Joi.string().valid(...COMPARATORS),
+	search_type: Joi.string().valid(...COMPARATORS),
+	value: Joi.any(),
+	search_value: Joi.any(),
+})
+	.or('attribute', 'search_attribute')
+	.or('comparator', 'search_type')
+	.or('value', 'search_value');
+
+// A condition group. The nested `conditions` array is left unconstrained for
+// the same reason searchByConditionsSchema leaves it unconstrained: shallow
+// validation here is enough to reject scalar/wrong-type inputs at the boundary.
+const groupConditionSchema = Joi.object({
+	operator: Joi.string().valid('and', 'or'),
+	conditions: Joi.array().required(),
+});
+
+// `.strict()` disables Joi's default type coercion so a numeric string like
+// '1779834663816' is rejected for a `Joi.number()` field instead of being
+// silently converted. Strictness propagates to child schemas.
+const getAnalyticsSchema = Joi.object({
+	metric: Joi.string().required(),
+	start_time: Joi.number().greater(0),
+	end_time: Joi.number().greater(0),
+	get_attributes: Joi.array().items(Joi.string()),
+	coalesce_time: Joi.boolean(),
+	conditions: Joi.array().items(Joi.alternatives(groupConditionSchema, directConditionSchema)),
+	replicated: Joi.boolean(),
+}).strict();
+
+export function validateGetAnalytics(req: any): Error | undefined {
+	return validator.validateBySchema(req, getAnalyticsSchema);
+}

package/core/validation/{bulkDeleteValidator.js → bulkDeleteValidator.ts}

@@ -1,6 +1,6 @@
-const validator = require('./validationWrapper.js');
-const Joi = require('joi');
-const { hdbTable, hdbDatabase } = require('./common_validators.js');
+import * as validator from './validationWrapper.ts';
+import Joi from 'joi';
+import { hdbTable, hdbDatabase } from './common_validators.ts';
 
 const validationSchema = {
 	schema: hdbDatabase,
@@ -16,9 +16,9 @@ const timestampSchema = {
 	timestamp: Joi.date().timestamp().required().messages({ 'date.format': "'timestamp' is invalid" }),
 };
 
-module.exports = function (deleteObject, dateFormat) {
+export default function (deleteObject: any, dateFormat: any) {
 	const finalSchema =
 		dateFormat === 'timestamp' ? { ...validationSchema, ...timestampSchema } : { ...validationSchema, ...dateSchema };
 	const bulkDeleteSchema = Joi.object(finalSchema);
 	return validator.validateBySchema(deleteObject, bulkDeleteSchema);
-};
+}

package/core/validation/{check_permissions.js → check_permissions.ts}

@@ -1,4 +1,4 @@
-const validator = require('./validationWrapper.js');
+import * as validator from './validationWrapper.ts';
 
 const constraints = {
 	user: {
@@ -14,6 +14,6 @@ const constraints = {
 		presence: true,
 	},
 };
-module.exports = function (deleteObject) {
+export default function (deleteObject) {
 	return validator.validateObject(deleteObject, constraints);
-};
+}

package/core/validation/{common_validators.js → common_validators.ts}

@@ -1,11 +1,11 @@
 'use strict';
 
-const hdbUtils = require('../utility/common_utils.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const schemaRegex = /^[\x20-\x2E|\x30-\x5F|\x61-\x7E]*$/;
-const Joi = require('joi');
+import * as hdbUtils from '../utility/common_utils.ts';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+export const schemaRegex = /^[\x20-\x2E|\x30-\x5F|\x61-\x7E]*$/;
+import Joi from 'joi';
 
-const commonValidators = {
+export const commonValidators = {
 	schema_format: {
 		pattern: schemaRegex,
 		message: 'names cannot include backticks or forward slashes',
@@ -18,7 +18,7 @@ const commonValidators = {
 };
 
 // A Joi schema that can be used to validate hdb schemas and tables.
-const hdbSchemaTable = Joi.alternatives(
+export const hdbSchemaTable = Joi.alternatives(
 	Joi.string()
 		.min(1)
 		.max(commonValidators.schema_length.maximum)
@@ -28,7 +28,7 @@ const hdbSchemaTable = Joi.alternatives(
 	Joi.array()
 ).required();
 
-const hdbDatabase = Joi.alternatives(
+export const hdbDatabase = Joi.alternatives(
 	Joi.string()
 		.min(1)
 		.max(commonValidators.schema_length.maximum)
@@ -37,7 +37,7 @@ const hdbDatabase = Joi.alternatives(
 	Joi.number()
 );
 
-const hdbTable = Joi.alternatives(
+export const hdbTable = Joi.alternatives(
 	Joi.string()
 		.min(1)
 		.max(commonValidators.schema_length.maximum)
@@ -46,7 +46,7 @@ const hdbTable = Joi.alternatives(
 	Joi.number()
 ).required();
 
-function checkValidTable(propertyName, value) {
+export function checkValidTable(propertyName, value) {
 	if (!value) return `'${propertyName}' is required`;
 	if (typeof value !== 'string') return `'${propertyName}' must be a string`;
 	if (!value.length) return `'${propertyName}' must be at least one character`;
@@ -55,7 +55,7 @@ function checkValidTable(propertyName, value) {
 	return '';
 }
 
-function validateSchemaExists(value, helpers) {
+export function validateSchemaExists(value, helpers) {
 	if (!hdbUtils.doesSchemaExist(value)) {
 		return helpers.message(`Database '${value}' does not exist`);
 	}
@@ -63,7 +63,7 @@ function validateSchemaExists(value, helpers) {
 	return value;
 }
 
-function validateTableExists(value, helpers) {
+export function validateTableExists(value, helpers) {
 	const schema = helpers.state.ancestors[0].schema;
 	if (!hdbUtils.doesTableExist(schema, value)) {
 		return helpers.message(`Table '${value}' does not exist`);
@@ -72,7 +72,7 @@ function validateTableExists(value, helpers) {
 	return value;
 }
 
-function validateSchemaName(value, helpers) {
+export function validateSchemaName(value, helpers) {
 	if (value.toLowerCase() === hdbTerms.SYSTEM_SCHEMA_NAME) {
 		return helpers.message(
 			`'subscriptions[${helpers.state.path[1]}]' invalid database name, '${hdbTerms.SYSTEM_SCHEMA_NAME}' name is reserved`
@@ -81,15 +81,3 @@ function validateSchemaName(value, helpers) {
 
 	return value;
 }
-
-module.exports = {
-	commonValidators,
-	schemaRegex,
-	hdbSchemaTable,
-	validateSchemaExists,
-	validateTableExists,
-	validateSchemaName,
-	checkValidTable,
-	hdbDatabase,
-	hdbTable,
-};

package/core/validation/{configValidator.js → configValidator.ts}

@@ -1,15 +1,15 @@
 'use strict';
 
-const fs = require('fs-extra');
-const Joi = require('joi');
-const os = require('os');
+import * as fs from 'fs-extra';
+import Joi from 'joi';
+import * as os from 'os';
 const { boolean, string, number, array } = Joi.types();
-const { totalmem } = require('os');
-const path = require('path');
-const hdbLogger = require('../utility/logging/harper_logger.js');
-const hdbUtils = require('../utility/common_utils.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const validator = require('./validationWrapper.js');
+import { totalmem } from 'os';
+import * as path from 'path';
+import * as hdbLogger from '../utility/logging/harper_logger.ts';
+import * as hdbUtils from '../utility/common_utils.ts';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as validator from './validationWrapper.ts';
 
 const DEFAULT_LOG_FOLDER = 'log';
 const DEFAULT_COMPONENTS_FOLDER = 'components';
@@ -24,7 +24,7 @@ const UNDEFINED_OPS_API = 'rootPath config parameter is undefined';
 const portConstraints = Joi.alternatives([number.min(0), string])
 	.optional()
 	.empty(null);
-const routeConstraints = Joi.alternatives([
+export const routeConstraints = Joi.alternatives([
 	array
 		.items(
 			string,
@@ -44,13 +44,7 @@ const routeConstraints = Joi.alternatives([
 let hdbRoot;
 let skipFsVal = false;
 
-module.exports = {
-	configValidator,
-	routesValidator,
-	routeConstraints,
-};
-
-function configValidator(configJson, skipFsValidation = false) {
+export function configValidator(configJson, skipFsValidation = false) {
 	skipFsVal = skipFsValidation;
 	hdbRoot = configJson.rootPath;
 	if (hdbUtils.isEmpty(hdbRoot)) {
@@ -72,6 +66,104 @@ function configValidator(configJson, skipFsValidation = false) {
 		privateKey: pemFileConstraints,
 	});
 
+	// MCP — sub-issue #613 lands the config surface ahead of the transport (#614).
+	// Presence-based enablement: a profile is on iff its sub-block exists in
+	// config (same convention as `replication`). No `enabled` field.
+	const mcpRateLimitSchema = Joi.object({
+		perToolPerSecond: number.min(0).optional(),
+		perToolBurst: number.min(0).optional(),
+		sessionConcurrency: number.min(0).optional(),
+		sessionPerSecond: number.min(0).optional(),
+	});
+	const mcpOperationsSchema = Joi.object({
+		mountPath: string.optional().default('/mcp'),
+		allow: array.items(string).optional(),
+		deny: array.items(string).optional(),
+		maxTools: number.min(1).optional(),
+		rateLimit: mcpRateLimitSchema.optional(),
+	});
+	const mcpApplicationSchema = mcpOperationsSchema.keys({
+		searchMaxResults: number.min(1).optional(),
+	});
+	const mcpSessionSchema = Joi.object({
+		idleTimeoutSeconds: number.min(1).optional(),
+		allowClientDelete: boolean.optional(),
+	});
+	const mcpSchema = Joi.object({
+		operations: mcpOperationsSchema.optional(),
+		application: mcpApplicationSchema.optional(),
+		session: mcpSessionSchema.optional(),
+	});
+
+	// Models — `models:` block opts a deployment into the per-backend registry.
+	// Per-backend shape is validated by a discriminated alternative on the
+	// `backend` field. Phase 2 (#629) lands ollama; Phase 3 (#630) lands openai.
+	//
+	// `.unknown(false)` on each known backend's schema turns field-name typos
+	// (`bakend: ollama`, `hsot: ...`) into boot-blocking validation errors.
+	// Without it, Joi's top-level `allowUnknown: true` propagates and typos
+	// silently survive into bootstrap. Unknown backend types (anything not in
+	// the `switch` list) fall through to a permissive schema so future Harper
+	// versions or third-party components can register their own backends
+	// without core schema edits — `bootstrapModels` logs+skips at runtime.
+	//
+	// `requestTimeoutMs: min(1)` (not `min(0)`) so the meaning is unambiguous:
+	// omit the field for "no timeout". `0` would validate but `composeSignal`
+	// treats it as "no timeout" via `if (!timeoutMs)`, surprising a test that
+	// sets 0 to mean "fail immediately".
+	const commonEntryFields = {
+		model: string.optional(),
+		requestTimeoutMs: number.min(1).optional(),
+	};
+	const ollamaEntrySchema = Joi.object({
+		backend: string.valid('ollama').required(),
+		host: string.optional(),
+		...commonEntryFields,
+	}).unknown(false);
+	const openaiEntrySchema = Joi.object({
+		backend: string.valid('openai').required(),
+		// `apiKey` may be a literal secret or a `${ENV_VAR}` placeholder; both
+		// are syntactically strings. `bootstrap.ts` runs `expandEnvVarsDeep`
+		// before construction; the backend rejects unresolved placeholders
+		// with an explicit error pointing at the env-var name.
+		apiKey: string.required(),
+		baseUrl: string.optional(),
+		organization: string.optional(),
+		...commonEntryFields,
+	}).unknown(false);
+	const anthropicEntrySchema = Joi.object({
+		backend: string.valid('anthropic').required(),
+		// Same secret-handling posture as openai's `apiKey`.
+		apiKey: string.required(),
+		baseUrl: string.optional(),
+		...commonEntryFields,
+	}).unknown(false);
+	const bedrockEntrySchema = Joi.object({
+		backend: string.valid('bedrock').required(),
+		// AWS credentials resolve via the SDK chain (env / shared file / IAM
+		// roles for service accounts) — no apiKey field. `region` is
+		// effectively required (Bedrock is regional) but the backend can
+		// fall back to AWS_REGION env, so we leave it optional here.
+		region: string.optional(),
+		...commonEntryFields,
+	}).unknown(false);
+	const unknownBackendEntrySchema = Joi.object({
+		backend: string.required(),
+	}).unknown(true);
+	const modelEntrySchema = Joi.alternatives().conditional('.backend', {
+		switch: [
+			{ is: 'ollama', then: ollamaEntrySchema },
+			{ is: 'openai', then: openaiEntrySchema },
+			{ is: 'anthropic', then: anthropicEntrySchema },
+			{ is: 'bedrock', then: bedrockEntrySchema },
+		],
+		otherwise: unknownBackendEntrySchema,
+	});
+	const modelsSchema = Joi.object({
+		embedding: Joi.object().pattern(Joi.string(), modelEntrySchema).optional(),
+		generative: Joi.object().pattern(Joi.string(), modelEntrySchema).optional(),
+	});
+
 	const configSchema = Joi.object({
 		authentication: Joi.alternatives(
 			Joi.object({
@@ -99,6 +191,8 @@ function configValidator(configJson, skipFsValidation = false) {
 			databases: Joi.alternatives(string, array),
 			enableRootCAs: boolean.optional(),
 			copyTablesToCatchUp: boolean.optional(),
+			pingInterval: number.min(1).optional().empty(null),
+			pingTimeout: number.min(1).optional().empty(null),
 		}).optional(),
 		componentsRoot: rootConstraints.optional(),
 		localStudio: Joi.object({
@@ -201,6 +295,8 @@ function configValidator(configJson, skipFsValidation = false) {
 			maxFreeSpaceToLoad: number.optional(),
 			maxFreeSpaceToRetain: number.optional(),
 		}).required(),
+		mcp: mcpSchema.optional(),
+		models: modelsSchema.optional(),
 		ignoreScripts: boolean.optional(),
 		tls: Joi.alternatives([Joi.array().items(tlsConstraints), tlsConstraints]),
 	});
@@ -331,7 +427,7 @@ function setDefaultRoot(parent, helpers) {
  * @param routesArray
  * @returns {*}
  */
-function routesValidator(routesArray) {
+export function routesValidator(routesArray) {
 	const schema = Joi.object({
 		routes: routeConstraints,
 	});

package/core/validation/{deleteValidator.js → deleteValidator.ts}

@@ -1,6 +1,6 @@
-const validator = require('./validationWrapper.js');
-const Joi = require('joi');
-const { hdbTable, hdbDatabase } = require('./common_validators.js');
+import * as validator from './validationWrapper.ts';
+import Joi from 'joi';
+import { hdbTable, hdbDatabase } from './common_validators.ts';
 
 const deleteSchema = Joi.object({
 	schema: hdbDatabase,
@@ -10,6 +10,6 @@ const deleteSchema = Joi.object({
 	ids: Joi.array(),
 });
 
-module.exports = function (deleteObject) {
+export default function (deleteObject: any) {
 	return validator.validateBySchema(deleteObject, deleteSchema);
-};
+}

package/core/validation/{fileLoadValidator.js → fileLoadValidator.ts}

@@ -1,14 +1,14 @@
-const clone = require('clone');
-const validator = require('./validationWrapper.js');
-const commonUtils = require('../utility/common_utils.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const fs = require('fs');
-const joi = require('joi');
+import clone from 'clone';
+import * as validator from './validationWrapper.ts';
+import * as commonUtils from '../utility/common_utils.ts';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as fs from 'fs';
+import joi from 'joi';
 const { string } = joi.types();
-const { hdbErrors, handleHDBError } = require('../utility/errors/hdbError.js');
+import { hdbErrors, handleHDBError } from '../utility/errors/hdbError.ts';
 const { HTTP_STATUS_CODES } = hdbErrors;
 
-const { commonValidators } = require('./common_validators.js');
+import { commonValidators } from './common_validators.ts';
 
 const isRequiredString = ' is required';
 
@@ -96,22 +96,22 @@ const urlSchema = clone(baseJoiSchema);
 urlSchema.csv_url = string.uri().messages({ 'string.uri': "'csv_url' must be a valid url" }).required();
 urlSchema.passthrough_headers = joi.object();
 
-function dataObject(object) {
+export function dataObject(object) {
 	let validateRes = validator.validateObject(object, dataConstraints);
 	return postValidateChecks(object, validateRes);
 }
 
-function urlObject(object) {
+export function urlObject(object) {
 	let validateRes = validator.validateBySchema(object, joi.object(urlSchema));
 	return postValidateChecks(object, validateRes);
 }
 
-function fileObject(object) {
+export function fileObject(object) {
 	let validateRes = validator.validateObject(object, fileConstraints);
 	return postValidateChecks(object, validateRes);
 }
 
-function s3FileObject(object) {
+export function s3FileObject(object) {
 	let validateRes = validator.validateObject(object, s3FileConstraints);
 	return postValidateChecks(object, validateRes);
 }
@@ -144,10 +144,3 @@ function postValidateChecks(object, validateRes) {
 	}
 	return validateRes;
 }
-
-module.exports = {
-	dataObject,
-	urlObject,
-	fileObject,
-	s3FileObject,
-};

package/core/validation/{insertValidator.js → insertValidator.ts}

@@ -1,6 +1,6 @@
-const { hdbTable, hdbDatabase } = require('./common_validators.js');
-const validator = require('./validationWrapper.js');
-const Joi = require('joi');
+import { hdbTable, hdbDatabase } from './common_validators.ts';
+import * as validator from './validationWrapper.ts';
+import Joi from 'joi';
 const INVALID_ATTRIBUTE_NAMES = {
 	undefined: 'undefined',
 	null: 'null',
@@ -35,6 +35,6 @@ const insertSchema = Joi.object({
 	records: Joi.array().items(Joi.object().custom(customRecordsVal)).required(),
 });
 
-module.exports = function (insertObject) {
+export default function (insertObject: any) {
 	return validator.validateBySchema(insertObject, insertSchema);
-};
+}