@stonyx/orm 0.2.1-alpha.40 → 0.2.1-alpha.42

package/dist/db.js

@@ -128,7 +128,7 @@ export default class DB {
             await Promise.all(collectionKeys.map(async (key) => {
                 const filePath = path.join(dirPath, `${key}.json`);
                 const exists = await fileExists(filePath);
-                const data = jsonData[key] || [];
+                const data = (jsonData[key] || []);
                 if (exists)
                     await updateFile(filePath, data, { json: true });
                 else

package/dist/hooks.d.ts

@@ -2,7 +2,35 @@
  * Middleware-based hooks registry for ORM operations.
  * Unlike event-based hooks, middleware hooks run sequentially and can halt operations.
  */
-type HookHandler = (context: Record<string, unknown>) => unknown | Promise<unknown>;
+/** Context object passed to before/after hook handlers. */
+export interface HookContext {
+    /** Model name (e.g. 'user', 'animal'). */
+    model: string;
+    /** Operation name: 'create', 'update', 'delete', 'get', or 'list'. */
+    operation: string;
+    /** The incoming HTTP request object. */
+    request?: unknown;
+    /** URL route parameters (e.g. { id: '42' }). */
+    params?: Record<string, string>;
+    /** Parsed request body for create/update operations. */
+    body?: Record<string, unknown>;
+    /** URL query string parameters. */
+    query?: Record<string, string>;
+    /** Mutable state bag shared across hooks within a single request. */
+    state?: Record<string, unknown>;
+    /** Previous record state (available in update hooks). */
+    oldState?: unknown;
+    /** Target record ID for single-record operations. */
+    recordId?: string | number;
+    /** Response data (available in after hooks). */
+    response?: unknown;
+    /** The affected record (available in after hooks for create/update/delete). */
+    record?: unknown;
+    /** The affected records (available in after hooks for list operations). */
+    records?: unknown[];
+    [key: string]: unknown;
+}
+type HookHandler = (context: HookContext) => unknown | Promise<unknown>;
 /**
  * Register a before hook middleware that runs before the operation executes.
  *

package/dist/mysql/schema-introspector.d.ts

@@ -1,7 +1,7 @@
 import type { ForeignKeyDef, ModelSchema, ViewSchema, SnapshotEntry } from '../types/orm-types.js';
 export declare function introspectModels(): Record<string, ModelSchema>;
 export declare function buildTableDDL(name: string, schema: ModelSchema, allSchemas?: Record<string, ModelSchema>): string;
-export declare function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[];
+export { getTopologicalOrder } from '../schema-helpers.js';
 export declare function introspectViews(): Record<string, ViewSchema>;
 export declare function buildViewDDL(name: string, viewSchema: ViewSchema, modelSchemas?: Record<string, ModelSchema>): string;
 export declare function viewSchemasToSnapshot(viewSchemas: Record<string, ViewSchema>): Record<string, ViewSnapshotEntry>;

package/dist/mysql/schema-introspector.js

@@ -4,21 +4,8 @@ import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from '../plural-registry.js';
 import { dbKey } from '../db.js';
 import { AggregateProperty } from '../aggregates.js';
+import { getRelationshipInfo, sanitizeTableName } from '../schema-helpers.js';
 import ModelProperty from '../model-property.js';
-function getRelationshipInfo(property) {
-    if (typeof property !== 'function')
-        return null;
-    const relType = property.__relationshipType;
-    const modelName = property.__relatedModelName || null;
-    if (relType === 'belongsTo')
-        return { type: 'belongsTo', modelName };
-    if (relType === 'hasMany')
-        return { type: 'hasMany', modelName };
-    return null;
-}
-function sanitizeTableName(name) {
-    return name.replace(/[-/]/g, '_');
-}
 export function introspectModels() {
     const { models } = Orm.instance;
     const schemas = {};
@@ -112,28 +99,7 @@ function getReferencedIdType(tableName, allSchemas) {
     // Default to INT if referenced table not found in schemas
     return 'INT';
 }
-export function getTopologicalOrder(schemas) {
-    const visited = new Set();
-    const order = [];
-    function visit(name) {
-        if (visited.has(name))
-            return;
-        visited.add(name);
-        const schema = schemas[name];
-        if (!schema)
-            return;
-        // Visit dependencies (belongsTo targets) first
-        for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-            if (targetModelName)
-                visit(targetModelName);
-        }
-        order.push(name);
-    }
-    for (const name of Object.keys(schemas)) {
-        visit(name);
-    }
-    return order;
-}
+export { getTopologicalOrder } from '../schema-helpers.js';
 export function introspectViews() {
     const orm = Orm.instance;
     if (!orm.views)

package/dist/orm-request.js

@@ -470,5 +470,6 @@ export default class OrmRequest extends Request {
             return 403;
         if (typeof access === 'function')
             state.filter = access;
+        return undefined;
     }
 }

package/dist/postgres/schema-introspector.d.ts

@@ -21,9 +21,8 @@ export declare function buildTableDDL(name: string, schema: ModelSchema, allSche
  * Build HNSW index DDL for vector columns on a model.
  */
 export declare function buildVectorIndexDDL(name: string, schema: ModelSchema): string[];
-export declare function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[];
+export { getTopologicalOrder } from '../schema-helpers.js';
 export declare function introspectViews(): Record<string, ViewSchema>;
 export declare function buildViewDDL(name: string, viewSchema: ViewSchema, modelSchemas?: Record<string, ModelSchema>): string;
 export declare function viewSchemasToSnapshot(viewSchemas: Record<string, ViewSchema>): Record<string, ViewSnapshotEntry>;
 export declare function schemasToSnapshot(schemas: Record<string, ModelSchema>): Record<string, ModelSnapshotEntry>;
-export {};

package/dist/postgres/schema-introspector.js

@@ -4,21 +4,8 @@ import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from '../plural-registry.js';
 import { dbKey } from '../db.js';
 import { AggregateProperty } from '../aggregates.js';
+import { getRelationshipInfo, sanitizeTableName } from '../schema-helpers.js';
 import ModelProperty from '../model-property.js';
-function getRelationshipInfo(property) {
-    if (typeof property !== 'function')
-        return null;
-    const relType = property.__relationshipType;
-    const modelName = property.__relatedModelName || null;
-    if (relType === 'belongsTo')
-        return { type: 'belongsTo', modelName };
-    if (relType === 'hasMany')
-        return { type: 'hasMany', modelName };
-    return null;
-}
-function sanitizeTableName(name) {
-    return name.replace(/[-/]/g, '_');
-}
 export function introspectModels() {
     const { models } = Orm.instance;
     const schemas = {};
@@ -129,28 +116,7 @@ function getReferencedIdType(tableName, allSchemas) {
     }
     return 'INTEGER';
 }
-export function getTopologicalOrder(schemas) {
-    const visited = new Set();
-    const order = [];
-    function visit(name) {
-        if (visited.has(name))
-            return;
-        visited.add(name);
-        const schema = schemas[name];
-        if (!schema)
-            return;
-        // Visit dependencies (belongsTo targets) first
-        for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-            if (targetModelName)
-                visit(targetModelName);
-        }
-        order.push(name);
-    }
-    for (const name of Object.keys(schemas)) {
-        visit(name);
-    }
-    return order;
-}
+export { getTopologicalOrder } from '../schema-helpers.js';
 export function introspectViews() {
     const orm = Orm.instance;
     if (!orm.views)

package/dist/schema-helpers.d.ts

@@ -0,0 +1,20 @@
+import type { ModelSchema } from './types/orm-types.js';
+export interface SchemaRelationshipInfo {
+    type: 'belongsTo' | 'hasMany';
+    modelName: string | null;
+}
+/**
+ * Detect relationship type and target model from a model property function.
+ * Returns null if the property is not a relationship.
+ */
+export declare function getRelationshipInfo(property: unknown): SchemaRelationshipInfo | null;
+/**
+ * Sanitize a model/table name for use in SQL identifiers.
+ * Replaces hyphens and slashes with underscores.
+ */
+export declare function sanitizeTableName(name: string): string;
+/**
+ * Sort model schemas in dependency order (belongsTo targets before dependents).
+ * Uses depth-first traversal to ensure referenced tables are created first.
+ */
+export declare function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[];

package/dist/schema-helpers.js

@@ -0,0 +1,48 @@
+/**
+ * Detect relationship type and target model from a model property function.
+ * Returns null if the property is not a relationship.
+ */
+export function getRelationshipInfo(property) {
+    if (typeof property !== 'function')
+        return null;
+    const relType = property.__relationshipType;
+    const modelName = property.__relatedModelName || null;
+    if (relType === 'belongsTo')
+        return { type: 'belongsTo', modelName };
+    if (relType === 'hasMany')
+        return { type: 'hasMany', modelName };
+    return null;
+}
+/**
+ * Sanitize a model/table name for use in SQL identifiers.
+ * Replaces hyphens and slashes with underscores.
+ */
+export function sanitizeTableName(name) {
+    return name.replace(/[-/]/g, '_');
+}
+/**
+ * Sort model schemas in dependency order (belongsTo targets before dependents).
+ * Uses depth-first traversal to ensure referenced tables are created first.
+ */
+export function getTopologicalOrder(schemas) {
+    const visited = new Set();
+    const order = [];
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        const schema = schemas[name];
+        if (!schema)
+            return;
+        // Visit dependencies (belongsTo targets) first
+        for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
+            if (targetModelName)
+                visit(targetModelName);
+        }
+        order.push(name);
+    }
+    for (const name of Object.keys(schemas)) {
+        visit(name);
+    }
+    return order;
+}

package/dist/store.js

@@ -119,14 +119,14 @@ export default class Store {
     unloadRecord(model, id, options = {}) {
         const modelStore = this.data.get(model);
         if (!modelStore) {
-            console.warn(`[Store] Cannot unload record: model "${model}" not found in store`);
+            console.warn(`[Store] Cannot unload record: model "${model}" not found in store — ensure the model is registered before unloading`);
             return;
         }
         if (typeof id !== 'string' && typeof id !== 'number')
             return;
         const raw = modelStore.get(id);
         if (!raw || !isStoreRecord(raw)) {
-            console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store`);
+            console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store — it may have already been unloaded`);
             return;
         }
         const record = raw;
@@ -145,7 +145,7 @@ export default class Store {
     unloadAllRecords(model, options = {}) {
         const modelStore = this.data.get(model);
         if (!modelStore) {
-            console.warn(`[Store] Cannot unload all records: model "${model}" not found in store`);
+            console.warn(`[Store] Cannot unload all records: model "${model}" not found in store — ensure the model is registered before unloading`);
             return;
         }
         const recordIds = Array.from(modelStore.keys());

package/dist/types/orm-types.d.ts

@@ -5,7 +5,7 @@ export interface OrmDbConfig {
     mode: string;
     directory: string;
     autosave: string;
-    saveInterval: unknown;
+    saveInterval: string | number;
 }
 export interface OrmMysqlConfig {
     host: string;
@@ -63,23 +63,23 @@ export interface SourceRecord {
     };
     __data?: Record<string, unknown>;
     __relationships?: Record<string, unknown>;
-    id: unknown;
+    id: string | number;
     [key: string]: unknown;
 }
 export interface OrmRecord {
-    id: string | number | unknown;
+    id: string | number;
     __model?: {
         __name: string;
     };
     __data: Record<string, unknown> & {
-        id?: unknown;
+        id?: string | number;
         __pendingSqlId?: boolean;
     };
     __relationships: Record<string, unknown>;
     toJSON?(options?: {
         fields?: Set<string>;
         baseUrl?: string;
-    }): unknown;
+    }): Record<string, unknown>;
     [key: string]: unknown;
 }
 export interface ForeignKeyDef {

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.1-alpha.40",
+  "version": "0.2.1-alpha.42",
   "description": "",
   "main": "dist/index.js",
   "type": "module",

package/src/db.ts

@@ -167,7 +167,7 @@ export default class DB {
       await Promise.all(collectionKeys.map(async key => {
         const filePath = path.join(dirPath, `${key}.json`);
         const exists = await fileExists(filePath);
-        const data = jsonData[key] || [];
+        const data = (jsonData[key] || []) as Record<string, unknown> | unknown[];
 
         if (exists) await updateFile(filePath, data, { json: true });
         else await createFile(filePath, data, { json: true });

package/src/hooks.ts

@@ -19,7 +19,36 @@
  * Unlike event-based hooks, middleware hooks run sequentially and can halt operations.
  */
 
-type HookHandler = (context: Record<string, unknown>) => unknown | Promise<unknown>;
+/** Context object passed to before/after hook handlers. */
+export interface HookContext {
+  /** Model name (e.g. 'user', 'animal'). */
+  model: string;
+  /** Operation name: 'create', 'update', 'delete', 'get', or 'list'. */
+  operation: string;
+  /** The incoming HTTP request object. */
+  request?: unknown;
+  /** URL route parameters (e.g. { id: '42' }). */
+  params?: Record<string, string>;
+  /** Parsed request body for create/update operations. */
+  body?: Record<string, unknown>;
+  /** URL query string parameters. */
+  query?: Record<string, string>;
+  /** Mutable state bag shared across hooks within a single request. */
+  state?: Record<string, unknown>;
+  /** Previous record state (available in update hooks). */
+  oldState?: unknown;
+  /** Target record ID for single-record operations. */
+  recordId?: string | number;
+  /** Response data (available in after hooks). */
+  response?: unknown;
+  /** The affected record (available in after hooks for create/update/delete). */
+  record?: unknown;
+  /** The affected records (available in after hooks for list operations). */
+  records?: unknown[];
+  [key: string]: unknown;
+}
+
+type HookHandler = (context: HookContext) => unknown | Promise<unknown>;
 
 // Map of "operation:model" -> handler[]
 const beforeHooks: Map<string, HookHandler[]> = new Map();

package/src/mysql/schema-introspector.ts

@@ -4,39 +4,15 @@ import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from '../plural-registry.js';
 import { dbKey } from '../db.js';
 import { AggregateProperty } from '../aggregates.js';
+import { getRelationshipInfo, sanitizeTableName } from '../schema-helpers.js';
 import type { ForeignKeyDef, ModelSchema, ViewSchema, SnapshotEntry } from '../types/orm-types.js';
 import ModelProperty from '../model-property.js';
 
-interface RelationshipInfo {
-  type: 'belongsTo' | 'hasMany';
-  modelName: string | null;
-}
-
 interface JoinClause {
   table: string;
   condition: string;
 }
 
-interface RelationshipProperty {
-  __relatedModelName?: string | null;
-  __relationshipType?: string;
-}
-
-function getRelationshipInfo(property: unknown): RelationshipInfo | null {
-  if (typeof property !== 'function') return null;
-  const relType = (property as RelationshipProperty).__relationshipType;
-  const modelName = (property as RelationshipProperty).__relatedModelName || null;
-
-  if (relType === 'belongsTo') return { type: 'belongsTo', modelName };
-  if (relType === 'hasMany') return { type: 'hasMany', modelName };
-
-  return null;
-}
-
-function sanitizeTableName(name: string): string {
-  return name.replace(/[-/]/g, '_');
-}
-
 export function introspectModels(): Record<string, ModelSchema> {
   const { models } = (Orm as unknown as { instance: { models: Record<string, unknown>; transforms: Record<string, unknown> } }).instance;
   const schemas: Record<string, ModelSchema> = {};
@@ -143,31 +119,7 @@ function getReferencedIdType(tableName: string, allSchemas: Record<string, Model
   return 'INT';
 }
 
-export function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[] {
-  const visited = new Set<string>();
-  const order: string[] = [];
-
-  function visit(name: string): void {
-    if (visited.has(name)) return;
-    visited.add(name);
-
-    const schema = schemas[name];
-    if (!schema) return;
-
-    // Visit dependencies (belongsTo targets) first
-    for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-      if (targetModelName) visit(targetModelName);
-    }
-
-    order.push(name);
-  }
-
-  for (const name of Object.keys(schemas)) {
-    visit(name);
-  }
-
-  return order;
-}
+export { getTopologicalOrder } from '../schema-helpers.js';
 
 export function introspectViews(): Record<string, ViewSchema> {
   const orm = (Orm as unknown as { instance: { views?: Record<string, unknown>; transforms: Record<string, unknown> } }).instance;

package/src/orm-request.ts

@@ -3,6 +3,7 @@ import Orm, { store, createRecord, updateRecord } from '@stonyx/orm';
 import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from './plural-registry.js';
 import { getBeforeHooks, getAfterHooks } from './hooks.js';
+import type { HookContext } from './hooks.js';
 import config from 'stonyx/config';
 import type { OrmRecord } from './types/orm-types.js';
 import { isOrmRecord } from './utils.js';
@@ -26,22 +27,6 @@ interface Filter {
   value: string;
 }
 
-interface HookContext {
-  model: string;
-  operation: string;
-  request: OrmRequest$;
-  params: { [key: string]: string };
-  body?: { [key: string]: unknown };
-  query?: { [key: string]: string };
-  state: { [key: string]: unknown };
-  oldState?: unknown;
-  recordId?: string | number;
-  response?: unknown;
-  record?: unknown;
-  records?: unknown;
-  [key: string]: unknown;
-}
-
 interface JsonApiResponse {
   data: unknown;
   links?: { [key: string]: string };
@@ -592,5 +577,6 @@ export default class OrmRequest extends Request {
     if (!access) return 403;
     if (Array.isArray(access) && !access.includes(methodAccessMap[request.method])) return 403;
     if (typeof access === 'function') state.filter = access;
+    return undefined;
   }
 }

package/src/postgres/postgres-db.ts

@@ -507,7 +507,7 @@ export default class PostgresDB {
     // Re-key the record in the store if PostgreSQL generated the ID (via RETURNING)
     if (isPendingId && result.rows.length > 0) {
       const pendingId = record.id;
-      const realId = result.rows[0].id;
+      const realId = result.rows[0].id as string | number;
       const modelStore = (this.deps.store as unknown as { get(name: string): Map<unknown, unknown> }).get(modelName);
 
       modelStore.delete(pendingId);

package/src/postgres/schema-introspector.ts

@@ -4,14 +4,10 @@ import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from '../plural-registry.js';
 import { dbKey } from '../db.js';
 import { AggregateProperty } from '../aggregates.js';
+import { getRelationshipInfo, sanitizeTableName } from '../schema-helpers.js';
 import type { ForeignKeyDef, ModelSchema, ViewSchema } from '../types/orm-types.js';
 import ModelProperty from '../model-property.js';
 
-interface RelationshipInfo {
-  type: 'belongsTo' | 'hasMany';
-  modelName: string | null;
-}
-
 interface ViewSnapshotEntry {
   viewName: string;
   source: string;
@@ -35,21 +31,6 @@ interface JoinDef {
   condition: string;
 }
 
-function getRelationshipInfo(property: unknown): RelationshipInfo | null {
-  if (typeof property !== 'function') return null;
-  const relType = (property as { __relationshipType?: string }).__relationshipType;
-  const modelName = (property as { __relatedModelName?: string }).__relatedModelName || null;
-
-  if (relType === 'belongsTo') return { type: 'belongsTo', modelName };
-  if (relType === 'hasMany') return { type: 'hasMany', modelName };
-
-  return null;
-}
-
-function sanitizeTableName(name: string): string {
-  return name.replace(/[-/]/g, '_');
-}
-
 export function introspectModels(): Record<string, ModelSchema> {
   const { models } = Orm.instance as { models: Record<string, unknown> };
   const schemas: Record<string, ModelSchema> = {};
@@ -177,31 +158,7 @@ function getReferencedIdType(tableName: string, allSchemas: Record<string, Model
   return 'INTEGER';
 }
 
-export function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[] {
-  const visited = new Set<string>();
-  const order: string[] = [];
-
-  function visit(name: string): void {
-    if (visited.has(name)) return;
-    visited.add(name);
-
-    const schema = schemas[name];
-    if (!schema) return;
-
-    // Visit dependencies (belongsTo targets) first
-    for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-      if (targetModelName) visit(targetModelName);
-    }
-
-    order.push(name);
-  }
-
-  for (const name of Object.keys(schemas)) {
-    visit(name);
-  }
-
-  return order;
-}
+export { getTopologicalOrder } from '../schema-helpers.js';
 
 export function introspectViews(): Record<string, ViewSchema> {
   const orm = Orm.instance as { views?: Record<string, unknown> };

package/src/schema-helpers.ts

@@ -0,0 +1,59 @@
+import type { ModelSchema } from './types/orm-types.js';
+
+export interface SchemaRelationshipInfo {
+  type: 'belongsTo' | 'hasMany';
+  modelName: string | null;
+}
+
+/**
+ * Detect relationship type and target model from a model property function.
+ * Returns null if the property is not a relationship.
+ */
+export function getRelationshipInfo(property: unknown): SchemaRelationshipInfo | null {
+  if (typeof property !== 'function') return null;
+  const relType = (property as { __relationshipType?: string }).__relationshipType;
+  const modelName = (property as { __relatedModelName?: string }).__relatedModelName || null;
+
+  if (relType === 'belongsTo') return { type: 'belongsTo', modelName };
+  if (relType === 'hasMany') return { type: 'hasMany', modelName };
+
+  return null;
+}
+
+/**
+ * Sanitize a model/table name for use in SQL identifiers.
+ * Replaces hyphens and slashes with underscores.
+ */
+export function sanitizeTableName(name: string): string {
+  return name.replace(/[-/]/g, '_');
+}
+
+/**
+ * Sort model schemas in dependency order (belongsTo targets before dependents).
+ * Uses depth-first traversal to ensure referenced tables are created first.
+ */
+export function getTopologicalOrder(schemas: Record<string, ModelSchema>): string[] {
+  const visited = new Set<string>();
+  const order: string[] = [];
+
+  function visit(name: string): void {
+    if (visited.has(name)) return;
+    visited.add(name);
+
+    const schema = schemas[name];
+    if (!schema) return;
+
+    // Visit dependencies (belongsTo targets) first
+    for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
+      if (targetModelName) visit(targetModelName);
+    }
+
+    order.push(name);
+  }
+
+  for (const name of Object.keys(schemas)) {
+    visit(name);
+  }
+
+  return order;
+}

package/src/serializer.ts

@@ -33,7 +33,7 @@ function query(rawData: unknown, pathPrefix: string, subPath: unknown): unknown
 
   const [path, getter, pointer] = makeArray(subPath) as [string, unknown, string | undefined];
   const fullPath = `${pathPrefix}${path}`;
-  const value = get(rawData, fullPath);
+  const value = get(rawData as Record<string, unknown>, fullPath);
 
   if (getter === undefined || getter === null) return value;
 

package/src/store.ts

@@ -185,14 +185,14 @@ export default class Store {
     const modelStore = this.data.get(model);
 
     if (!modelStore) {
-      console.warn(`[Store] Cannot unload record: model "${model}" not found in store`);
+      console.warn(`[Store] Cannot unload record: model "${model}" not found in store — ensure the model is registered before unloading`);
       return;
     }
 
     if (typeof id !== 'string' && typeof id !== 'number') return;
     const raw = modelStore.get(id);
     if (!raw || !isStoreRecord(raw)) {
-      console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store`);
+      console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store — it may have already been unloaded`);
       return;
     }
     const record = raw;
@@ -217,7 +217,7 @@ export default class Store {
     const modelStore = this.data.get(model);
 
     if (!modelStore) {
-      console.warn(`[Store] Cannot unload all records: model "${model}" not found in store`);
+      console.warn(`[Store] Cannot unload all records: model "${model}" not found in store — ensure the model is registered before unloading`);
       return;
     }
 

package/src/transforms.ts

@@ -7,7 +7,7 @@ const transforms: Record<string, (value: unknown) => unknown> = {
   number: (value: unknown) => parseInt(value as string),
   passthrough: (value: unknown) => value,
   string: (value: unknown) => String(value),
-  timestamp: (value: unknown) => getTimestamp(value),
+  timestamp: (value: unknown) => getTimestamp(value as string | number | Date | undefined),
   trim: (value: unknown) => (value as string)?.trim(),
   uppercase: (value: unknown) => (value as string)?.toUpperCase(),
 };

package/src/types/mysql2.d.ts

@@ -5,16 +5,35 @@ declare module 'mysql2/promise' {
     password: string;
     database: string;
     port?: number;
-    [key: string]: unknown;
+    waitForConnections?: boolean;
+    connectionLimit?: number;
+    queueLimit?: number;
+    enableKeepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    [key: string]: string | number | boolean | undefined;
   }
 
-  interface QueryResult {
-    [index: number]: unknown;
+  interface ExecuteResult {
+    insertId: number;
+    affectedRows: number;
+    changedRows: number;
+    fieldCount: number;
+    info: string;
+    serverStatus: number;
+    warningStatus: number;
   }
 
+  interface FieldPacket {
+    name: string;
+    type: number;
+    length: number;
+  }
+
+  type RowDataPacket = Record<string, string | number | boolean | null>;
+
   interface Pool {
-    execute(sql: string, params?: unknown[]): Promise<[unknown[], unknown]>;
-    query(sql: string, params?: unknown[]): Promise<[unknown[], unknown]>;
+    execute(sql: string, params?: unknown[]): Promise<[RowDataPacket[] | ExecuteResult, FieldPacket[]]>;
+    query(sql: string, params?: unknown[]): Promise<[RowDataPacket[] | ExecuteResult, FieldPacket[]]>;
     end(): Promise<void>;
     getConnection(): Promise<PoolConnection>;
   }

package/src/types/orm-types.ts

@@ -6,7 +6,7 @@ export interface OrmDbConfig {
   mode: string;
   directory: string;
   autosave: string;
-  saveInterval: unknown;
+  saveInterval: string | number;
 }
 
 export interface OrmMysqlConfig {
@@ -68,16 +68,16 @@ export interface SourceRecord {
   __model: { __name: string; [key: string]: unknown };
   __data?: Record<string, unknown>;
   __relationships?: Record<string, unknown>;
-  id: unknown;
+  id: string | number;
   [key: string]: unknown;
 }
 
 export interface OrmRecord {
-  id: string | number | unknown;
+  id: string | number;
   __model?: { __name: string };
-  __data: Record<string, unknown> & { id?: unknown; __pendingSqlId?: boolean };
+  __data: Record<string, unknown> & { id?: string | number; __pendingSqlId?: boolean };
   __relationships: Record<string, unknown>;
-  toJSON?(options?: { fields?: Set<string>; baseUrl?: string }): unknown;
+  toJSON?(options?: { fields?: Set<string>; baseUrl?: string }): Record<string, unknown>;
   [key: string]: unknown;
 }
 

package/src/types/pg.d.ts

@@ -5,13 +5,17 @@ declare module 'pg' {
     password?: string;
     database?: string;
     port?: number;
-    [key: string]: unknown;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
   }
 
+  type RowData = Record<string, string | number | boolean | null>;
+
   interface QueryResult {
-    rows: Record<string, unknown>[];
+    rows: RowData[];
     rowCount: number;
-    fields?: { name: string }[];
+    fields?: { name: string; dataTypeID: number }[];
   }
 
   export class Pool {

package/src/types/stonyx-rest-server.d.ts

@@ -3,9 +3,14 @@ declare module '@stonyx/rest-server' {
     constructor(...args: unknown[]);
   }
 
+  interface RouteOptions {
+    name: string;
+    options?: { model: string; access: (request: unknown) => unknown } | Record<string, unknown>;
+  }
+
   export default class RestServer {
     static instance: RestServer;
     static close(): void;
-    mountRoute(RequestClass: unknown, options: { name: string; options?: unknown }): void;
+    mountRoute(RequestClass: typeof Request, options: RouteOptions): void;
   }
 }

package/src/types/stonyx-utils.d.ts

@@ -1,13 +1,13 @@
 declare module '@stonyx/utils/file' {
-  export function createFile(path: string, data: unknown, options?: { json?: boolean }): Promise<void>;
+  export function createFile(path: string, data: string | Record<string, unknown> | unknown[], options?: { json?: boolean }): Promise<void>;
   export function createDirectory(path: string): Promise<void>;
-  export function updateFile(path: string, data: unknown, options?: { json?: boolean }): Promise<void>;
-  export function readFile(path: string, options?: { json?: boolean; missingFileCallback?: () => Promise<unknown> }): Promise<unknown>;
+  export function updateFile(path: string, data: string | Record<string, unknown> | unknown[], options?: { json?: boolean }): Promise<void>;
+  export function readFile(path: string, options?: { json?: boolean; missingFileCallback?: () => Promise<Record<string, unknown>> }): Promise<string | Record<string, unknown> | unknown[]>;
   export function fileExists(path: string): Promise<boolean>;
   export function deleteDirectory(path: string): Promise<void>;
   export function forEachFileImport(
     path: string,
-    callback: (exported: unknown, meta: { name: string }) => unknown,
+    callback: (exported: Function | Record<string, unknown>, meta: { name: string }) => void | unknown,
     options?: { ignoreAccessFailure?: boolean; rawName?: boolean; recursive?: boolean; recursiveNaming?: boolean }
   ): Promise<void>;
 }
@@ -19,13 +19,13 @@ declare module '@stonyx/utils/string' {
 }
 
 declare module '@stonyx/utils/object' {
-  export function get(obj: unknown, path: string): unknown;
+  export function get(obj: Record<string, unknown>, path: string): unknown;
   export function getOrSet<T>(map: Map<unknown, T>, key: unknown, defaultValue: T): T;
   export function makeArray<T>(value: T | T[]): T[];
 }
 
 declare module '@stonyx/utils/date' {
-  export function getTimestamp(value?: unknown): number;
+  export function getTimestamp(value?: string | number | Date): number;
 }
 
 declare module '@stonyx/utils/prompt' {