@stonyx/orm 0.2.1-beta.83 → 0.2.1-beta.84

package/src/{hooks.js → hooks.ts}

@@ -19,26 +19,28 @@
  * Unlike event-based hooks, middleware hooks run sequentially and can halt operations.
  */
 
+type HookHandler = (context: Record<string, unknown>) => unknown | Promise<unknown>;
+
 // Map of "operation:model" -> handler[]
-const beforeHooks = new Map();
-const afterHooks = new Map();
+const beforeHooks: Map<string, HookHandler[]> = new Map();
+const afterHooks: Map<string, HookHandler[]> = new Map();
 
 /**
  * Register a before hook middleware that runs before the operation executes.
  *
- * @param {string} operation - Operation name: 'create', 'update', 'delete', 'get', or 'list'
- * @param {string} model - Model name (e.g., 'user', 'animal')
- * @param {Function} handler - Middleware function (context) => any
+ * @param operation - Operation name: 'create', 'update', 'delete', 'get', or 'list'
+ * @param model - Model name (e.g., 'user', 'animal')
+ * @param handler - Middleware function (context) => any
  *   - Return undefined to continue to next hook/handler
  *   - Return any value to halt operation (integer = HTTP status, object = response body)
- * @returns {Function} Unsubscribe function
+ * @returns Unsubscribe function
  */
-export function beforeHook(operation, model, handler) {
+export function beforeHook(operation: string, model: string, handler: HookHandler): () => void {
   const key = `${operation}:${model}`;
   if (!beforeHooks.has(key)) {
     beforeHooks.set(key, []);
   }
-  beforeHooks.get(key).push(handler);
+  beforeHooks.get(key)!.push(handler);
 
   // Return unsubscribe function
   return () => {
@@ -54,17 +56,17 @@ export function beforeHook(operation, model, handler) {
  * Register an after hook middleware that runs after the operation completes.
  * After hooks cannot halt operations (they run after completion).
  *
- * @param {string} operation - Operation name
- * @param {string} model - Model name
- * @param {Function} handler - Middleware function (context) => void
- * @returns {Function} Unsubscribe function
+ * @param operation - Operation name
+ * @param model - Model name
+ * @param handler - Middleware function (context) => void
+ * @returns Unsubscribe function
  */
-export function afterHook(operation, model, handler) {
+export function afterHook(operation: string, model: string, handler: HookHandler): () => void {
   const key = `${operation}:${model}`;
   if (!afterHooks.has(key)) {
     afterHooks.set(key, []);
   }
-  afterHooks.get(key).push(handler);
+  afterHooks.get(key)!.push(handler);
 
   // Return unsubscribe function
   return () => {
@@ -78,22 +80,16 @@ export function afterHook(operation, model, handler) {
 
 /**
  * Get all before hooks for an operation:model combination.
- * @param {string} operation
- * @param {string} model
- * @returns {Function[]}
  */
-export function getBeforeHooks(operation, model) {
+export function getBeforeHooks(operation: string, model: string): HookHandler[] {
   const key = `${operation}:${model}`;
   return beforeHooks.get(key) || [];
 }
 
 /**
  * Get all after hooks for an operation:model combination.
- * @param {string} operation
- * @param {string} model
- * @returns {Function[]}
  */
-export function getAfterHooks(operation, model) {
+export function getAfterHooks(operation: string, model: string): HookHandler[] {
   const key = `${operation}:${model}`;
   return afterHooks.get(key) || [];
 }
@@ -101,11 +97,11 @@ export function getAfterHooks(operation, model) {
 /**
  * Clear registered hooks for a specific operation:model.
  *
- * @param {string} operation - Operation name
- * @param {string} model - Model name
- * @param {string} [type] - 'before' or 'after' (if omitted, clears both)
+ * @param operation - Operation name
+ * @param model - Model name
+ * @param type - 'before' or 'after' (if omitted, clears both)
  */
-export function clearHook(operation, model, type) {
+export function clearHook(operation: string, model: string, type?: 'before' | 'after'): void {
   const key = `${operation}:${model}`;
   if (!type || type === 'before') {
     beforeHooks.set(key, []);
@@ -118,7 +114,7 @@ export function clearHook(operation, model, type) {
 /**
  * Clear all hooks (useful for testing).
  */
-export function clearAllHooks() {
+export function clearAllHooks(): void {
   beforeHooks.clear();
   afterHooks.clear();
 }

package/src/{index.js → index.ts}

@@ -32,7 +32,7 @@ export { count, avg, sum, min, max }; // aggregate helpers
 export { beforeHook, afterHook, clearHook, clearAllHooks } from './hooks.js'; // middleware hooks
 
 // Store API:
-// store.get(model, id)   — sync, memory-only
-// store.find(model, id)  — async, MySQL for memory:false models
-// store.findAll(model)   — async, all records
-// store.query(model, conditions) — async, always hits MySQL
+// store.get(model, id)   -- sync, memory-only
+// store.find(model, id)  -- async, MySQL for memory:false models
+// store.findAll(model)   -- async, all records
+// store.query(model, conditions) -- async, always hits MySQL

package/src/{main.js → main.ts}

@@ -26,22 +26,46 @@ import Store from './store.js';
 import Serializer from './serializer.js';
 import { setup } from '@stonyx/events';
 
-const defaultOptions = {
+interface OrmOptions {
+  dbType?: string;
+}
+
+export interface SqlDb {
+  init(): Promise<unknown>;
+  startup(): Promise<void>;
+  shutdown(): Promise<void>;
+  persist(operation: string, model: string, context: unknown, response: unknown): Promise<void>;
+  findRecord(modelName: string, id: unknown): Promise<unknown>;
+  findAll(modelName: string, conditions?: Record<string, unknown>): Promise<unknown[]>;
+}
+
+export interface OrmDB {
+  record: unknown;
+  save(): Promise<void>;
+  init(): Promise<void>;
+}
+
+const defaultOptions: OrmOptions = {
   dbType: 'json'
 }
 
 export default class Orm {
-  static initialized = false;
-  static relationships = new Map();
-  static store = new Store();
-  
-  models = {};
-  serializers = {};
-  views = {};
-  transforms = { ...baseTransforms };
-  warnings = new Set();
-
-  constructor(options={}) {
+  static initialized: boolean = false;
+  static relationships: Map<string, Map<string, unknown>> = new Map();
+  static store: Store = new Store();
+  static instance: Orm;
+  static ready: unknown[];
+
+  models: Record<string, unknown> = {};
+  serializers: Record<string, unknown> = {};
+  views: Record<string, unknown> = {};
+  transforms: Record<string, (value: unknown) => unknown> = { ...baseTransforms };
+  warnings: Set<string> = new Set();
+  options!: OrmOptions;
+  sqlDb?: SqlDb;
+  db?: OrmDB | SqlDb;
+
+  constructor(options: OrmOptions = {}) {
     if (Orm.instance) return Orm.instance;
 
     const { relationships } = Orm;
@@ -56,24 +80,25 @@ export default class Orm {
     Orm.instance = this;
   }
 
-  async init() {
+  async init(): Promise<void> {
     const { paths, restServer } = config.orm;
-    const promises = ['Model', 'Serializer', 'Transform'].map(type => {
+
+    const promises: Promise<unknown>[] = ['Model', 'Serializer', 'Transform'].map(type => {
       const lowerCaseType = type.toLowerCase();
       const path = paths[lowerCaseType];
 
       if (!path) throw new Error(`Configuration Error: ORM path for "${type}" must be defined.`);
 
-      return forEachFileImport(path, (exported, { name }) => {
+      return forEachFileImport(path, (exported: unknown, { name }: { name: string }) => {
         // Transforms keep their original name, everything else gets converted to PascalCase with the type suffix
         const alias = type === 'Transform' ? name : `${kebabCaseToPascalCase(name)}${type}`;
 
         if (type === 'Model') {
           Orm.store.set(name, new Map());
-          registerPluralName(name, exported);
+          registerPluralName(name, exported as { pluralName?: string });
         }
 
-        return this[pluralize(lowerCaseType)][alias] = exported;
+        return (this as unknown as Record<string, Record<string, unknown>>)[pluralize(lowerCaseType)][alias] = exported;
       }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
     });
 
@@ -82,16 +107,16 @@ export default class Orm {
 
     // Discover views from paths.view (separate from model/serializer/transform)
     if (paths.view) {
-      await forEachFileImport(paths.view, (exported, { name }) => {
+      await forEachFileImport(paths.view, (exported: unknown, { name }: { name: string }) => {
         const alias = `${kebabCaseToPascalCase(name)}View`;
         Orm.store.set(name, new Map());
-        registerPluralName(name, exported);
+        registerPluralName(name, exported as { pluralName?: string });
         this.views[alias] = exported;
       }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
     }
 
     // Setup event names for hooks after models are loaded
-    const eventNames = [];
+    const eventNames: string[] = [];
     const operations = ['list', 'get', 'create', 'update', 'delete'];
     const viewOperations = ['list', 'get'];
     const timings = ['before', 'after'];
@@ -111,17 +136,17 @@ export default class Orm {
 
     if (config.orm.timescale) {
       const { default: TimescaleDB } = await import('./timescale/timescale-db.js');
-      this.sqlDb = new TimescaleDB();
+      this.sqlDb = new TimescaleDB() as SqlDb;
       this.db = this.sqlDb;
       promises.push(this.sqlDb.init());
     } else if (config.orm.postgres) {
       const { default: PostgresDB } = await import('./postgres/postgres-db.js');
-      this.sqlDb = new PostgresDB();
+      this.sqlDb = new PostgresDB() as SqlDb;
       this.db = this.sqlDb;
       promises.push(this.sqlDb.init());
     } else if (config.orm.mysql) {
       const { default: MysqlDB } = await import('./mysql/mysql-db.js');
-      this.sqlDb = new MysqlDB();
+      this.sqlDb = new MysqlDB() as SqlDb;
       this.db = this.sqlDb;
       promises.push(this.sqlDb.init());
     } else if (this.options.dbType !== 'none') {
@@ -136,9 +161,9 @@ export default class Orm {
     }
 
     // Wire up memory resolver so store.find() can check model memory flags
-    Orm.store._memoryResolver = (modelName) => {
+    Orm.store._memoryResolver = (modelName: string): boolean => {
       const { modelClass } = this.getRecordClasses(modelName);
-      return modelClass?.memory === true;
+      return (modelClass as { memory?: boolean })?.memory === true;
     };
 
     // Wire up SQL adapter reference for on-demand queries from store.find()/findAll()
@@ -150,21 +175,21 @@ export default class Orm {
     Orm.initialized = true;
   }
 
-  async startup() {
+  async startup(): Promise<void> {
     if (this.sqlDb) await this.sqlDb.startup();
   }
 
-  async shutdown() {
+  async shutdown(): Promise<void> {
     if (this.sqlDb) await this.sqlDb.shutdown();
   }
 
-  static get db() {
+  static get db(): OrmDB | SqlDb {
     if (!Orm.initialized) throw new Error('ORM has not been initialized yet');
 
-    return Orm.instance.db;
+    return Orm.instance.db!;
   }
 
-  getRecordClasses(modelName) {
+  getRecordClasses(modelName: string): { modelClass: unknown; serializerClass: unknown } {
     const modelClassPrefix = kebabCaseToPascalCase(modelName);
 
     // Check views first, then models
@@ -182,21 +207,21 @@ export default class Orm {
     };
   }
 
-  isView(modelName) {
+  isView(modelName: string): boolean {
     const modelClassPrefix = kebabCaseToPascalCase(modelName);
     return !!this.views[`${modelClassPrefix}View`];
   }
 
   // Queue warnings to avoid the same error from being logged in the same iteration
-  warn(message) {
+  warn(message: string): void {
     this.warnings.add(message);
 
     setTimeout(() => {
-      this.warnings.forEach(warning => log.warn(warning));
+      this.warnings.forEach(warning => log.warn!(warning));
       this.warnings.clear();
     }, 0);
   }
 }
 
 export const store = Orm.store;
-export const relationships = Orm.relationships;
+export const relationships = Orm.relationships;

package/src/{manage-record.js → manage-record.ts}

@@ -1,13 +1,30 @@
-import Orm, { store, relationships } from '@stonyx/orm';
-import Record from './record.js';
+import Orm, { store } from '@stonyx/orm';
+import OrmRecord from './record.js';
+import { getGlobalRegistry, getPendingRegistry, getPendingBelongsToRegistry, getBelongsToRegistry, getHasManyRegistry } from './relationships.js';
+import type Serializer from './serializer.js';
+
+interface CreateRecordOptions {
+  isDbRecord?: boolean;
+  serialize?: boolean;
+  transform?: boolean;
+  update?: boolean;
+  [key: string]: unknown;
+}
+
+interface PendingBelongsToEntry {
+  sourceRecord: OrmRecord;
+  sourceModelName: string;
+  relationshipKey: string;
+  relationshipId: unknown;
+}
 
-const defaultOptions = {
+const defaultOptions: CreateRecordOptions = {
   isDbRecord: false,
   serialize: true,
   transform: true
 };
 
-export function createRecord(modelName, rawData={}, userOptions={}) {
+export function createRecord(modelName: string, rawData: { [key: string]: unknown } = {}, userOptions: CreateRecordOptions = {}): OrmRecord {
   const orm = Orm.instance;
   const { initialized } = Orm;
   const options = { ...defaultOptions, ...userOptions };
@@ -20,24 +37,26 @@ export function createRecord(modelName, rawData={}, userOptions={}) {
   }
 
   const modelStore = store.get(modelName);
-  const globalRelationships = relationships.get('global');
-  const pendingRelationships = relationships.get('pending');
+  const globalRelationships = getGlobalRegistry();
+  const pendingRelationships = getPendingRegistry();
 
   if (!modelStore) throw new Error(`Model store for '${modelName}' is not registered. Ensure the model is defined before creating records.`);
 
   assignRecordId(modelName, rawData);
-  if (modelStore.has(rawData.id)) return modelStore.get(rawData.id);
+  if (modelStore.has(rawData.id as number | string)) return modelStore.get(rawData.id as number | string)! as OrmRecord;
 
-  const { modelClass, serializerClass } = orm.getRecordClasses(modelName);
+  const recordClasses = orm.getRecordClasses(modelName);
+  const modelClass = recordClasses.modelClass as (new (name: string) => { __name: string; [key: string]: unknown }) | undefined;
+  const serializerClass = recordClasses.serializerClass as new (model: { [key: string]: unknown }) => Serializer;
 
   if (!modelClass) throw new Error(`A model named '${modelName}' does not exist`);
 
   const model = new modelClass(modelName);
   const serializer = new serializerClass(model);
-  const record = new Record(model, serializer);
+  const record = new OrmRecord(model, serializer);
 
   record.serialize(rawData, options);
-  modelStore.set(record.id, record);
+  modelStore.set(record.id as number | string, record);
 
   // populate global hasMany relationships
   const globalHasMany = globalRelationships.get(modelName);
@@ -51,12 +70,12 @@ export function createRecord(modelName, rawData={}, userOptions={}) {
   }
 
   // Fulfill pending belongsTo relationships
-  const pendingBelongsToQueue = relationships.get('pendingBelongsTo');
-  const pendingBelongsTo = pendingBelongsToQueue.get(modelName)?.get(record.id);
+  const pendingBelongsToQueue = getPendingBelongsToRegistry();
+  const pendingBelongsTo = pendingBelongsToQueue.get(modelName)?.get(record.id) as PendingBelongsToEntry[] | undefined;
 
   if (pendingBelongsTo) {
-    const belongsToReg = relationships.get('belongsTo');
-    const hasManyReg = relationships.get('hasMany');
+    const belongsToReg = getBelongsToRegistry();
+    const hasManyReg = getHasManyRegistry();
 
     for (const { sourceRecord, sourceModelName, relationshipKey, relationshipId } of pendingBelongsTo) {
       // Update the belongsTo relationship on the source record
@@ -87,7 +106,7 @@ export function createRecord(modelName, rawData={}, userOptions={}) {
   return record;
 }
 
-export function updateRecord(record, rawData, userOptions={}) {
+export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: CreateRecordOptions = {}): void {
   if (!rawData) throw new Error('rawData must be passed in to updateRecord call');
 
   // Guard: read-only views cannot be updated
@@ -96,7 +115,7 @@ export function updateRecord(record, rawData, userOptions={}) {
     throw new Error(`Cannot update records for read-only view '${modelName}'`);
   }
 
-  const options = { ...defaultOptions, ...userOptions, update:true };
+  const options = { ...defaultOptions, ...userOptions, update: true };
 
   record.serialize(rawData, options);
 }
@@ -107,7 +126,7 @@ export function updateRecord(record, rawData, userOptions={}) {
  * In MySQL mode with numeric IDs, assigns a temporary pending ID.
  * MySQL's AUTO_INCREMENT provides the real ID after INSERT.
  */
-function assignRecordId(modelName, rawData) {
+function assignRecordId(modelName: string, rawData: { [key: string]: unknown }): void {
   if (rawData.id) return;
 
   // In SQL mode with numeric IDs, defer to database auto-increment
@@ -117,15 +136,15 @@ function assignRecordId(modelName, rawData) {
     return;
   }
 
-  const modelStore = Array.from(store.get(modelName).values());
-  rawData.id = modelStore.length ? modelStore.at(-1).id + 1 : 1;
+  const modelStore = Array.from(store.get(modelName)!.values()) as OrmRecord[];
+  rawData.id = modelStore.length ? (modelStore.at(-1)!.id as number) + 1 : 1;
 }
 
-function isStringIdModel(modelName) {
-  const { modelClass } = Orm.instance.getRecordClasses(modelName);
+function isStringIdModel(modelName: string): boolean {
+  const modelClass = Orm.instance.getRecordClasses(modelName).modelClass as (new (name: string) => { [key: string]: unknown }) | undefined;
   if (!modelClass) return false;
 
   const model = new modelClass(modelName);
 
-  return model.id?.type === 'string';
+  return (model.id as { type?: string } | undefined)?.type === 'string';
 }

package/src/{meta-request.js → meta-request.ts}

@@ -1,37 +1,40 @@
 import { Request } from '@stonyx/rest-server';
+import ModelProperty from './model-property.js';
 import Orm from '@stonyx/orm';
 import config from 'stonyx/config';
 import { dbKey } from './db.js';
 
 export default class MetaRequest extends Request {
-  constructor() {
-    super(...arguments);
-    
+  handlers: Record<string, unknown>;
+
+  constructor(...args: unknown[]) {
+    super(...args);
+
     this.handlers = {
       get: {
         '/meta': () => {
           try {
-            const { models } = Orm.instance;
-            const metadata = {};
+            const { models } = Orm.instance as Orm;
+            const metadata: Record<string, Record<string, unknown>> = {};
 
             for (const [modelName, modelClass] of Object.entries(models)) {
               const name = modelName.slice(0, -5).toLowerCase();
 
               if (name === dbKey) continue;
 
-              const model = new modelClass(modelName);
-              const properties = {};
+              const model = new (modelClass as new (name: string) => Record<string, unknown>)(modelName);
+              const properties: Record<string, unknown> = {};
 
               // Get regular properties and relationships
               for (const [key, property] of Object.entries(model)) {
                 // Skip internal properties
                 if (key.startsWith('__')) continue;
 
-                if (property?.constructor?.name === 'ModelProperty') {
-                  properties[key] = { type: property.type };
+                if (property instanceof ModelProperty) {
+                  properties[key] = { type: (property as { type: string }).type };
                 } else if (typeof property === 'function') {
-                  const isBelongsTo = property.toString().includes(`getRelationships('belongsTo',`);
-                  const isHasMany = property.toString().includes(`getRelationships('hasMany',`);
+                  const isBelongsTo = (property as { __relationshipType?: string }).__relationshipType === 'belongsTo';
+                  const isHasMany = (property as { __relationshipType?: string }).__relationshipType === 'hasMany';
 
                   if (isBelongsTo || isHasMany) properties[key] = { [isBelongsTo ? 'belongsTo' : 'hasMany']: name };
                 }
@@ -40,16 +43,16 @@ export default class MetaRequest extends Request {
               metadata[name] = properties;
             }
 
-            return metadata;            
+            return metadata;
           } catch (error) {
-            return { error: error.message };
+            return { error: error instanceof Error ? error.message : String(error) };
           }
         },
       },
     }
   }
 
-  auth() {
+  auth(): number | undefined {
     if (!config.orm.restServer.metaRoute) return 403;
   }
 }

package/src/{migrate.js → migrate.ts}

@@ -4,10 +4,10 @@ import { createFile, createDirectory, readFile, updateFile, deleteDirectory } fr
 import { dbKey } from './db.js';
 import path from 'path';
 
-function getCollectionKeys() {
-  const SchemaClass = Orm.instance.models[`${dbKey}Model`];
+function getCollectionKeys(): string[] {
+  const SchemaClass = (Orm.instance as Orm).models[`${dbKey}Model`] as new () => Record<string, unknown>;
   const instance = new SchemaClass();
-  const keys = [];
+  const keys: string[] = [];
 
   for (const key of Object.keys(instance)) {
     if (key === '__name' || key === 'id') continue;
@@ -17,7 +17,7 @@ function getCollectionKeys() {
   return keys;
 }
 
-function getDirPath() {
+function getDirPath(): string {
   const { rootPath } = config;
   const { file, directory } = config.orm.db;
   const dbDir = path.dirname(path.resolve(`${rootPath}/${file}`));
@@ -25,7 +25,7 @@ function getDirPath() {
   return path.join(dbDir, directory);
 }
 
-export async function fileToDirectory() {
+export async function fileToDirectory(): Promise<void> {
   const { rootPath } = config;
   const { file } = config.orm.db;
   const dbFilePath = path.resolve(`${rootPath}/${file}`);
@@ -33,7 +33,7 @@ export async function fileToDirectory() {
   const dirPath = getDirPath();
 
   // Read full data from db.json
-  const data = await readFile(dbFilePath, { json: true });
+  const data = await readFile(dbFilePath, { json: true }) as Record<string, unknown[]>;
 
   // Create directory and write each collection
   await createDirectory(dirPath);
@@ -43,13 +43,13 @@ export async function fileToDirectory() {
   ));
 
   // Overwrite db.json with empty-array skeleton
-  const skeleton = {};
+  const skeleton: Record<string, unknown[]> = {};
   for (const key of collectionKeys) skeleton[key] = [];
 
   await updateFile(dbFilePath, skeleton, { json: true });
 }
 
-export async function directoryToFile() {
+export async function directoryToFile(): Promise<void> {
   const { rootPath } = config;
   const { file } = config.orm.db;
   const dbFilePath = path.resolve(`${rootPath}/${file}`);
@@ -57,7 +57,7 @@ export async function directoryToFile() {
   const dirPath = getDirPath();
 
   // Read each collection from the directory
-  const assembled = {};
+  const assembled: Record<string, unknown> = {};
 
   await Promise.all(collectionKeys.map(async key => {
     const filePath = path.join(dirPath, `${key}.json`);

package/src/{model-property.js → model-property.ts}

@@ -1,25 +1,31 @@
 import Orm from '@stonyx/orm';
 
-function validType(type) {
+function validType(type: string): boolean {
   return Object.keys(Orm.instance.transforms).includes(type);
 }
 
 export default class ModelProperty {
-  constructor(type='passthrough', defaultValue) {
+  readonly __kind = 'ModelProperty' as const;
+  type: string;
+  private _value: unknown;
+  ignoreFirstTransform?: boolean;
+
+  constructor(type: string = 'passthrough', defaultValue?: unknown) {
     if (!validType(type)) throw new Error(`Invalid model property type: ${type}`);
-    
+
     this.type = type;
     this.value = defaultValue;
   }
 
-  get value() {
+  get value(): unknown {
     return this._value;
   }
 
-  set value(newValue) {
+  set value(newValue: unknown) {
     if (this.ignoreFirstTransform) {
       delete this.ignoreFirstTransform;
-      return this._value = newValue;
+      this._value = newValue;
+      return;
     }
 
     if (newValue === undefined) return;

package/src/{model.js → model.ts}

@@ -1,4 +1,4 @@
-import { attr } from '@stonyx/orm';
+import attr from './attr.js';
 
 export default class Model {
   /**
@@ -9,12 +9,13 @@ export default class Model {
    *
    * Override in subclass: static memory = true;
    */
-  static memory = false;
-  static pluralName = undefined;
+  static memory: boolean = false;
+  static pluralName: string | undefined = undefined;
 
   id = attr('number');
+  __name: string;
 
-  constructor(name) {
+  constructor(name: string) {
     this.__name = name;
   }
 }