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

package/src/relationships.ts

@@ -0,0 +1,53 @@
+import { relationships } from '@stonyx/orm';
+import type { HasManyMap, BelongsToMap, GlobalMap, PendingMap, PendingBelongsToMap } from './types/orm-types.js';
+
+// TODO: Refactor mapping to remove a level of iteration
+export function getRelationships(type: string, sourceModel: string, targetModel: string, relationshipId?: string): Map<unknown, unknown> | undefined {
+  let allRelationships = relationships.get(type) as Map<string, Map<string, Map<unknown, unknown>>> | undefined;
+
+  if (!allRelationships) {
+    allRelationships = new Map();
+    relationships.set(type, allRelationships);
+  }
+
+  // create relationship map for this type of it doesn't already exist
+  if (!allRelationships.has(sourceModel)) allRelationships.set(sourceModel, new Map());
+
+  const modelRelationship = allRelationships.get(sourceModel)!;
+
+  if (!modelRelationship.has(targetModel)) modelRelationship.set(targetModel, new Map());
+
+  const relationship = modelRelationship.get(targetModel)!;
+
+  // TODO: Determine whether already having id should be handled differently
+  //if (relationship.has(relationshipId)) return;
+
+  return relationship;
+}
+
+export function getHasManyRelationships(sourceModel: string, targetModel: string): Map<unknown, unknown> | undefined {
+  return (relationships.get('hasMany') as HasManyMap | undefined)?.get(sourceModel)?.get(targetModel);
+}
+
+/** Typed accessors for the relationship registry */
+export function getHasManyRegistry(): HasManyMap {
+  return relationships.get('hasMany') as HasManyMap;
+}
+
+export function getBelongsToRegistry(): BelongsToMap {
+  return relationships.get('belongsTo') as BelongsToMap;
+}
+
+export function getGlobalRegistry(): GlobalMap {
+  return relationships.get('global') as GlobalMap;
+}
+
+export function getPendingRegistry(): PendingMap {
+  return relationships.get('pending') as PendingMap;
+}
+
+export function getPendingBelongsToRegistry(): PendingBelongsToMap {
+  return relationships.get('pendingBelongsTo') as PendingBelongsToMap;
+}
+
+export const TYPES: string[] = ['global', 'hasMany', 'belongsTo', 'pending'];

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

@@ -1,46 +1,57 @@
 import config from 'stonyx/config';
 import { get, makeArray } from '@stonyx/utils/object';
+import type { AggregateProperty } from './aggregates.js';
+import type ModelProperty from './model-property.js';
 
 const RESERVED_KEYS = ['__name'];
 
-function searchQuery(query, array, key) {
-  const result = makeArray(array).find(item => {
-    for (const [ prop, value ] of Object.entries(query)) {
-      if (item[prop] !== value) return false;
+function isAggregateProperty(v: unknown): v is AggregateProperty {
+  return typeof v === 'object' && v !== null && (v as { __kind?: string }).__kind === 'AggregateProperty';
+}
+
+function isModelProperty(v: unknown): v is ModelProperty {
+  return typeof v === 'object' && v !== null && (v as { __kind?: string }).__kind === 'ModelProperty';
+}
+
+function searchQuery(query: Record<string, unknown>, array: unknown, key?: string): unknown {
+  const result = makeArray(array).find((item: unknown) => {
+    for (const [prop, value] of Object.entries(query)) {
+      if ((item as Record<string, unknown>)[prop] !== value) return false;
 
       return true;
     }
   });
 
   if (!result) return null;
-  if (key) return result[key];
+  if (key) return (result as Record<string, unknown>)[key];
 
   return result;
 }
 
-function query(rawData, pathPrefix, subPath) {
+function query(rawData: unknown, pathPrefix: string, subPath: unknown): unknown {
   if (!rawData) return null;
 
-  const [ path, getter, pointer ] = makeArray(subPath);
+  const [path, getter, pointer] = makeArray(subPath) as [string, unknown, string | undefined];
   const fullPath = `${pathPrefix}${path}`;
   const value = get(rawData, fullPath);
 
   if (getter === undefined || getter === null) return value;
 
   try {
-    switch(typeof getter) {
+    switch (typeof getter) {
       case 'object':
-        return searchQuery(getter, value, pointer);
+        return searchQuery(getter as Record<string, unknown>, value, pointer);
 
       case 'function':
-        return getter(value);
+        return (getter as (v: unknown) => unknown)(value);
 
-      case 'number':
-        const element = value[getter];
-        return pointer ? element[pointer] : element;
+      case 'number': {
+        const element = (value as unknown[])[getter];
+        return pointer ? (element as Record<string, unknown>)[pointer] : element;
+      }
 
-      default: 
-        return value[getter];
+      default:
+        return (value as Record<string, unknown>)[getter as string];
     }
   } catch (error) {
     if (config.debug) console.error(`Cannot parse value for ${fullPath}.`, { getter, query }, error);
@@ -48,10 +59,11 @@ function query(rawData, pathPrefix, subPath) {
 }
 
 export default class Serializer {
-  map = {};
+  map: Record<string, unknown> = {};
   path = '';
+  model: Record<string, unknown>;
 
-  constructor(model) {
+  constructor(model: Record<string, unknown>) {
     this.model = model;
   }
 
@@ -60,14 +72,16 @@ export default class Serializer {
    * the ModelProperty object, while setting parsed values to the record's
    * __data property, which represents the serialized version of the data
    */
-  setProperties(rawData, record, options) {
+  setProperties(rawData: unknown, record: unknown, options: Record<string, unknown>): void {
     const { path, model } = this;
     const keys = Object.keys(model).filter(key => !RESERVED_KEYS.includes(key));
     const pathPrefix = path ? `${path}.` : '';
-    const { __data:parsedData, __relationships:relatedRecords } = record;
+    const rec = record as Record<string, unknown>;
+    const parsedData = rec.__data as Record<string, unknown>;
+    const relatedRecords = rec.__relationships as Record<string, unknown>;
 
     for (const key of keys) {
-      const subPath = options.serialize ? (this.map[key] || key) : key;
+      const subPath = options.serialize ? ((this.map as Record<string, unknown>)[key] || key) : key;
       const handler = model[key];
       const data = query(rawData, pathPrefix, subPath);
 
@@ -80,38 +94,40 @@ export default class Serializer {
         const handlerOptions = { ...options, _relationshipKey: key };
         const childRecord = handler(record, data, handlerOptions);
 
-        record[key] = childRecord
+        rec[key] = childRecord;
         relatedRecords[key] = childRecord;
 
         continue;
       }
 
       // Aggregate property handling — use the rawData value, not the aggregate descriptor
-      if (handler?.constructor?.name === 'AggregateProperty') {
+      if (isAggregateProperty(handler)) {
         parsedData[key] = data;
-        record[key] = data;
+        rec[key] = data;
         continue;
       }
 
       // Direct assignment handling
-      if (handler?.constructor?.name !== 'ModelProperty') {
+      if (!isModelProperty(handler)) {
         parsedData[key] = handler;
-        record[key] = handler;
+        rec[key] = handler;
         continue;
       }
 
+      const prop = handler as { value: unknown; ignoreFirstTransform: boolean };
+
       Object.defineProperty(record, key, {
         enumerable: true,
         configurable: true,
-        get: () => handler.value,
-        set(newValue) {
-          handler.ignoreFirstTransform = !options.transform;
-          handler.value = newValue;
-          parsedData[key] = handler.value;
+        get: () => prop.value,
+        set(newValue: unknown) {
+          prop.ignoreFirstTransform = !options.transform;
+          prop.value = newValue;
+          parsedData[key] = prop.value;
         }
       });
 
-      record[key] = data;
+      rec[key] = data;
     }
 
     if (options.update) return;
@@ -120,25 +136,25 @@ export default class Serializer {
     for (const [key, getter] of getComputedProperties(this.model)) {
       Object.defineProperty(record, key, {
         enumerable: true,
-        get: () => getter.call(record)
+        get: () => (getter as () => unknown).call(record)
       });
     }
 
-    record.__serialized = true;
+    rec.__serialized = true;
   }
 
   /**
    * OVERRIDE: This hook allows for data manipulation prior to serialization logic
    */
-  normalize(data) {
+  normalize(data: unknown): unknown {
     return data;
   }
 }
 
-export function getComputedProperties(classInstance) {
+export function getComputedProperties(classInstance: Record<string, unknown>): [string, PropertyDescriptor['get']][] {
   const proto = Object.getPrototypeOf(classInstance);
   if (!proto || proto === Object.prototype) return [];
-  
+
   return Object.entries(Object.getOwnPropertyDescriptors(proto))
     .filter(([key, descriptor]) => key !== 'constructor' && descriptor.get)
     .map(([key, descriptor]) => [key, descriptor.get]);

package/src/{setup-rest-server.js → setup-rest-server.ts}

@@ -8,32 +8,37 @@ import { dbKey } from './db.js';
 import { getPluralName } from './plural-registry.js';
 import log from 'stonyx/log';
 
-export default async function(route, accessPath, metaRoute) {
-  let accessFiles = {};
-  
+interface AccessInstance {
+  models: string[] | '*';
+  access: (request: unknown) => unknown;
+}
+
+export default async function(route: string, accessPath: string, metaRoute: boolean): Promise<void> {
+  let accessFiles: Record<string, (request: unknown) => unknown> | null = {};
+
   try {
-    await forEachFileImport(accessPath, accessClass => {
-      const accessInstance = new accessClass();
+    await forEachFileImport(accessPath, (accessClass: unknown) => {
+      const accessInstance = new (accessClass as new () => AccessInstance)();
       const { models } = accessInstance;
 
-      if (!models) throw new Error(`Access class "${accessClass.name}" must define a "models" list`);
+      if (!models) throw new Error(`Access class "${(accessClass as { name: string }).name}" must define a "models" list`);
 
       if (models.length === 0) return; // No models to assign access to
-      if (typeof accessInstance.access !== 'function') throw new Error(`Access class "${accessClass.name}" must declare an "access" method`);
+      if (typeof accessInstance.access !== 'function') throw new Error(`Access class "${(accessClass as { name: string }).name}" must declare an "access" method`);
 
       const availableModels = Array.from(store.data.keys());
 
       for (const model of models === '*' ? availableModels : models) {
         if (model === dbKey) continue;
         if (!store.data.has(model)) throw new Error(`Unable to define access for Invalid Model "${model}". Model does not exist`);
-        if (accessFiles[model]) throw new Error(`Access for model "${model}" has already been defined by another access class.`);
+        if (accessFiles![model]) throw new Error(`Access for model "${model}" has already been defined by another access class.`);
 
-        accessFiles[model] = accessInstance.access;
+        accessFiles![model] = accessInstance.access;
       }
     });
   } catch (error) {
-    log.error(error.message);
-    log.warn('You must define a valid access configuration file in order to access ORM generated REST endpoints.');
+    log.error!(error instanceof Error ? error.message : String(error));
+    log.warn!('You must define a valid access configuration file in order to access ORM generated REST endpoints.');
   }
 
   await waitForModule('rest-server');
@@ -42,7 +47,7 @@ export default async function(route, accessPath, metaRoute) {
   const name = route === '/' ? 'index' : (route[0] === '/' ? route.slice(1) : route);
 
   // Configure endpoints for models and views with access configuration
-  for (const [model, access] of Object.entries(accessFiles)) {
+  for (const [model, access] of Object.entries(accessFiles!)) {
     const pluralizedModel = getPluralName(model);
     const modelName = name === 'index' ? pluralizedModel : `${name}/${pluralizedModel}`;
     RestServer.instance.mountRoute(OrmRequest, { name: modelName, options: { model, access } });
@@ -50,7 +55,7 @@ export default async function(route, accessPath, metaRoute) {
 
   // Mount the meta route when metaRoute config is enabled
   if (metaRoute) {
-    log.warn('SECURITY RISK! - Meta route is enabled via metaRoute config. This feature is intended for development purposes only!');
+    log.warn!('SECURITY RISK! - Meta route is enabled via metaRoute config. This feature is intended for development purposes only!');
 
     RestServer.instance.mountRoute(MetaRequest, { name });
   }

package/src/{standalone-db.js → standalone-db.ts}

@@ -9,14 +9,23 @@
 import fs from 'fs/promises';
 import path from 'path';
 
+interface StandaloneDBOptions {
+  dbPath?: string;
+  mode?: 'file' | 'directory';
+  directory?: string;
+}
+
+interface DBRecord {
+  id: string | number;
+  [key: string]: unknown;
+}
+
 export default class StandaloneDB {
-  /**
-   * @param {Object} options
-   * @param {string} options.dbPath - Path to db.json (file mode) or parent of db dir (directory mode)
-   * @param {string} [options.mode='directory'] - 'file' or 'directory'
-   * @param {string} [options.directory='db'] - Directory name when mode is 'directory'
-   */
-  constructor(options = {}) {
+  readonly mode: 'file' | 'directory';
+  readonly dbPath: string;
+  readonly directory: string;
+
+  constructor(options: StandaloneDBOptions = {}) {
     this.mode = options.mode || 'directory';
     this.dbPath = options.dbPath || 'db.json';
     this.directory = options.directory || 'db';
@@ -25,7 +34,7 @@ export default class StandaloneDB {
   /**
    * Resolve the directory path for directory mode.
    */
-  getDirPath() {
+  getDirPath(): string {
     const dbDir = path.dirname(path.resolve(this.dbPath));
     return path.join(dbDir, this.directory);
   }
@@ -34,7 +43,7 @@ export default class StandaloneDB {
    * List available collections by inspecting either the db.json keys
    * or the files in the db directory.
    */
-  async getCollections() {
+  async getCollections(): Promise<string[]> {
     if (this.mode === 'directory') {
       const dirPath = this.getDirPath();
 
@@ -48,9 +57,9 @@ export default class StandaloneDB {
       }
     }
 
-    // File mode — read db.json and return its top-level keys
+    // File mode -- read db.json and return its top-level keys
     try {
-      const data = await this._readJSON(this.dbPath);
+      const data = await this._readJSON(this.dbPath) as Record<string, unknown>;
       return Object.keys(data).filter(key => Array.isArray(data[key]));
     } catch {
       return [];
@@ -60,20 +69,20 @@ export default class StandaloneDB {
   /**
    * Read all records for a collection.
    */
-  async readCollection(collection) {
+  async readCollection(collection: string): Promise<DBRecord[]> {
     if (this.mode === 'directory') {
       const filePath = path.join(this.getDirPath(), `${collection}.json`);
-      return this._readJSON(filePath);
+      return this._readJSON(filePath) as Promise<DBRecord[]>;
     }
 
-    const data = await this._readJSON(this.dbPath);
+    const data = await this._readJSON(this.dbPath) as Record<string, DBRecord[]>;
     return data[collection] || [];
   }
 
   /**
    * Write all records for a collection.
    */
-  async writeCollection(collection, records) {
+  async writeCollection(collection: string, records: DBRecord[]): Promise<void> {
     if (this.mode === 'directory') {
       const dirPath = this.getDirPath();
       await fs.mkdir(dirPath, { recursive: true });
@@ -83,11 +92,11 @@ export default class StandaloneDB {
       return;
     }
 
-    // File mode — read full db, update collection, write back
-    let data;
+    // File mode -- read full db, update collection, write back
+    let data: Record<string, unknown>;
 
     try {
-      data = await this._readJSON(this.dbPath);
+      data = await this._readJSON(this.dbPath) as Record<string, unknown>;
     } catch {
       data = {};
     }
@@ -99,7 +108,7 @@ export default class StandaloneDB {
   /**
    * Get a single record by id.
    */
-  async get(collection, id) {
+  async get(collection: string, id: string | number): Promise<DBRecord | null> {
     const records = await this.readCollection(collection);
     const numericId = Number(id);
 
@@ -111,14 +120,14 @@ export default class StandaloneDB {
   /**
    * List all records in a collection.
    */
-  async list(collection) {
+  async list(collection: string): Promise<DBRecord[]> {
     return this.readCollection(collection);
   }
 
   /**
    * Create a new record. Auto-assigns an integer id if none provided.
    */
-  async create(collection, data) {
+  async create(collection: string, data: DBRecord): Promise<DBRecord> {
     const records = await this.readCollection(collection);
 
     if (!data.id) {
@@ -145,7 +154,7 @@ export default class StandaloneDB {
   /**
    * Delete a record by id.
    */
-  async delete(collection, id) {
+  async delete(collection: string, id: string | number): Promise<DBRecord> {
     const records = await this.readCollection(collection);
     const numericId = Number(id);
 
@@ -165,12 +174,12 @@ export default class StandaloneDB {
 
   // -- Private helpers --
 
-  async _readJSON(filePath) {
+  private async _readJSON(filePath: string): Promise<unknown> {
     const content = await fs.readFile(filePath, 'utf-8');
     return JSON.parse(content);
   }
 
-  async _writeJSON(filePath, data) {
+  private async _writeJSON(filePath: string, data: unknown): Promise<void> {
     await fs.writeFile(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
   }
 }