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

package/dist/types/orm-types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function isDbError(error: unknown): error is {
+    code: string;
+    message: string;
+};
+export declare function pluralize(word: string): string;

package/dist/utils.js

@@ -0,0 +1,13 @@
+import { pluralize as basePluralize } from '@stonyx/utils/string';
+export function isDbError(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' && 'message' in error && typeof error.message === 'string';
+}
+// Wrapper to handle dasherized model names (e.g., "access-link" → "access-links")
+export function pluralize(word) {
+    if (word.includes('-')) {
+        const parts = word.split('-');
+        const pluralizedLast = basePluralize(parts.pop());
+        return [...parts, pluralizedLast].join('-');
+    }
+    return basePluralize(word);
+}

package/dist/view-resolver.d.ts

@@ -0,0 +1,8 @@
+export default class ViewResolver {
+    viewName: string;
+    constructor(viewName: string);
+    resolveAll(): Promise<unknown[]>;
+    private _resolvePerRecord;
+    private _resolveGroupBy;
+    resolveOne(id: unknown): Promise<unknown>;
+}

package/dist/view-resolver.js

@@ -0,0 +1,169 @@
+import Orm, { store } from '@stonyx/orm';
+import { createRecord } from './manage-record.js';
+import { AggregateProperty } from './aggregates.js';
+import { get } from '@stonyx/utils/object';
+export default class ViewResolver {
+    viewName;
+    constructor(viewName) {
+        this.viewName = viewName;
+    }
+    async resolveAll() {
+        const orm = Orm.instance;
+        const { modelClass: viewClass } = orm.getRecordClasses(this.viewName);
+        if (!viewClass)
+            return [];
+        const source = viewClass.source;
+        if (!source)
+            return [];
+        const sourceRecords = await store.findAll(source);
+        if (!sourceRecords || sourceRecords.length === 0) {
+            return [];
+        }
+        const resolveMap = viewClass.resolve || {};
+        const viewInstance = new viewClass(this.viewName);
+        const aggregateFields = {};
+        const regularFields = {};
+        // Categorize fields on the view instance
+        for (const [key, value] of Object.entries(viewInstance)) {
+            if (key.startsWith('__'))
+                continue;
+            if (key === 'id')
+                continue;
+            if (value instanceof AggregateProperty) {
+                aggregateFields[key] = value;
+            }
+            else if (typeof value !== 'function') {
+                // Regular attr or direct value — not a relationship handler
+                regularFields[key] = value;
+            }
+        }
+        const groupByField = viewClass.groupBy;
+        if (groupByField) {
+            return this._resolveGroupBy(sourceRecords, groupByField, aggregateFields, regularFields, resolveMap, viewClass);
+        }
+        return this._resolvePerRecord(sourceRecords, aggregateFields, regularFields, resolveMap, viewClass);
+    }
+    _resolvePerRecord(sourceRecords, aggregateFields, regularFields, resolveMap, viewClass) {
+        const results = [];
+        for (const sourceRecord of sourceRecords) {
+            const rawData = { id: sourceRecord.id };
+            // Compute aggregate fields from source record's relationships
+            for (const [key, aggProp] of Object.entries(aggregateFields)) {
+                if (!aggProp.relationship)
+                    continue;
+                const relatedRecords = sourceRecord.__relationships?.[aggProp.relationship]
+                    || sourceRecord[aggProp.relationship];
+                const relArray = Array.isArray(relatedRecords) ? relatedRecords : [];
+                rawData[key] = aggProp.compute(relArray);
+            }
+            // Apply resolve map entries
+            for (const [key, resolver] of Object.entries(resolveMap)) {
+                if (typeof resolver === 'function') {
+                    rawData[key] = resolver(sourceRecord);
+                }
+                else if (typeof resolver === 'string') {
+                    rawData[key] = get(sourceRecord.__data || sourceRecord, resolver)
+                        ?? get(sourceRecord, resolver);
+                }
+            }
+            // Map regular attr fields from source record if not already set
+            for (const key of Object.keys(regularFields)) {
+                if (rawData[key] !== undefined)
+                    continue;
+                const sourceValue = sourceRecord.__data?.[key] ?? sourceRecord[key];
+                if (sourceValue !== undefined) {
+                    rawData[key] = sourceValue;
+                }
+            }
+            // Set belongsTo source relationship
+            const viewInstanceForRel = new viewClass(this.viewName);
+            for (const [key, value] of Object.entries(viewInstanceForRel)) {
+                if (typeof value === 'function' && key !== 'id') {
+                    // This is a relationship handler — pass the source record id
+                    rawData[key] = sourceRecord.id;
+                }
+            }
+            // Clear existing record from store to allow re-resolution
+            const viewStore = store.get(this.viewName);
+            if (viewStore?.has(rawData.id)) {
+                viewStore.delete(rawData.id);
+            }
+            const record = createRecord(this.viewName, rawData, { isDbRecord: true });
+            results.push(record);
+        }
+        return results;
+    }
+    _resolveGroupBy(sourceRecords, groupByField, aggregateFields, regularFields, resolveMap, viewClass) {
+        // Group source records by the groupBy field value
+        const groups = new Map();
+        for (const record of sourceRecords) {
+            const key = record.__data?.[groupByField] ?? record[groupByField];
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(record);
+        }
+        const results = [];
+        for (const [groupKey, groupRecords] of groups) {
+            const rawData = { id: groupKey };
+            // Compute aggregate fields
+            for (const [key, aggProp] of Object.entries(aggregateFields)) {
+                if (aggProp.relationship === undefined) {
+                    // Field-level aggregate — compute over group records directly
+                    rawData[key] = aggProp.compute(groupRecords);
+                }
+                else {
+                    // Relationship aggregate — flatten related records across all group members
+                    if (!aggProp.relationship)
+                        continue;
+                    const allRelated = [];
+                    for (const record of groupRecords) {
+                        const relatedRecords = record.__relationships?.[aggProp.relationship]
+                            || record[aggProp.relationship];
+                        if (Array.isArray(relatedRecords)) {
+                            allRelated.push(...relatedRecords);
+                        }
+                    }
+                    rawData[key] = aggProp.compute(allRelated);
+                }
+            }
+            // Apply resolve map entries — functions receive the group array
+            for (const [key, resolver] of Object.entries(resolveMap)) {
+                if (typeof resolver === 'function') {
+                    rawData[key] = resolver(groupRecords);
+                }
+                else if (typeof resolver === 'string') {
+                    // String path — take value from first record in group
+                    const first = groupRecords[0];
+                    rawData[key] = get(first.__data || first, resolver)
+                        ?? get(first, resolver);
+                }
+            }
+            // Map regular attr fields from first record if not already set
+            for (const key of Object.keys(regularFields)) {
+                if (rawData[key] !== undefined)
+                    continue;
+                const first = groupRecords[0];
+                const sourceValue = first.__data?.[key] ?? first[key];
+                if (sourceValue !== undefined) {
+                    rawData[key] = sourceValue;
+                }
+            }
+            // Clear existing record from store to allow re-resolution
+            const viewStore = store.get(this.viewName);
+            if (viewStore?.has(rawData.id)) {
+                viewStore.delete(rawData.id);
+            }
+            const record = createRecord(this.viewName, rawData, { isDbRecord: true });
+            results.push(record);
+        }
+        return results;
+    }
+    async resolveOne(id) {
+        const all = await this.resolveAll();
+        return all.find((record) => {
+            const r = record;
+            return r.id === id || r.id == id;
+        });
+    }
+}

package/dist/view.d.ts

@@ -0,0 +1,11 @@
+export default class View {
+    static memory: boolean;
+    static readOnly: boolean;
+    static pluralName: string | undefined;
+    static source: string | undefined;
+    static groupBy: string | undefined;
+    static resolve: ((record: unknown) => unknown) | undefined;
+    id: import("./model-property.js").default;
+    __name: string;
+    constructor(name: string);
+}

package/dist/view.js

@@ -0,0 +1,18 @@
+import attr from './attr.js';
+export default class View {
+    static memory = false;
+    static readOnly = true;
+    static pluralName = undefined;
+    static source = undefined;
+    static groupBy = undefined;
+    static resolve = undefined;
+    id = attr('number');
+    __name;
+    constructor(name) {
+        this.__name = name;
+        // Enforce readOnly — cannot be overridden to false
+        if (this.constructor.readOnly !== true) {
+            throw new Error(`View '${name}' cannot override readOnly to false`);
+        }
+    }
+}

package/package.json

@@ -4,20 +4,38 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.1-beta.83",
+  "version": "0.2.1-beta.85",
   "description": "",
-  "main": "src/main.js",
+  "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "stonyx-orm": "./src/cli.js"
+    "stonyx-orm": "./dist/cli.js"
   },
   "exports": {
-    ".": "./src/index.js",
-    "./db": "./src/exports/db.js",
-    "./standalone-db": "./src/standalone-db.js",
-    "./migrate": "./src/migrate.js",
-    "./commands": "./src/commands.js",
-    "./hooks": "./src/hooks.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./db": {
+      "types": "./dist/exports/db.d.ts",
+      "default": "./dist/exports/db.js"
+    },
+    "./standalone-db": {
+      "types": "./dist/standalone-db.d.ts",
+      "default": "./dist/standalone-db.js"
+    },
+    "./migrate": {
+      "types": "./dist/migrate.d.ts",
+      "default": "./dist/migrate.js"
+    },
+    "./commands": {
+      "types": "./dist/commands.d.ts",
+      "default": "./dist/commands.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks.d.ts",
+      "default": "./dist/hooks.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -29,6 +47,7 @@
     "Stone Costa <stone.costa@synamicd.com>"
   ],
   "files": [
+    "dist",
     "src",
     "config",
     "README.md"
@@ -65,12 +84,16 @@
   "devDependencies": {
     "@stonyx/rest-server": "0.2.1-beta.30",
     "@stonyx/utils": "0.2.3-beta.7",
+    "@types/node": "^25.6.0",
     "mysql2": "^3.20.0",
     "pg": "^8.20.0",
     "qunit": "^2.24.1",
-    "sinon": "^21.0.0"
+    "sinon": "^21.0.0",
+    "typescript": "^5.8.3"
   },
   "scripts": {
-    "test": "stonyx test"
+    "build": "tsc",
+    "build:test": "tsc -p tsconfig.test.json",
+    "test": "npm run build && npm run build:test && stonyx test 'dist-test/test/**/*-test.js'"
   }
 }

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

@@ -1,5 +1,19 @@
+type AggregateType = 'count' | 'avg' | 'sum' | 'min' | 'max';
+
+interface AggregateRecord {
+  __data?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
 export class AggregateProperty {
-  constructor(aggregateType, relationship, field) {
+  readonly __kind = 'AggregateProperty' as const;
+  readonly aggregateType: AggregateType;
+  readonly relationship: string | undefined;
+  readonly field: string | undefined;
+  readonly mysqlFunction: string;
+  readonly resultType: 'float' | 'number';
+
+  constructor(aggregateType: AggregateType, relationship?: string, field?: string) {
     this.aggregateType = aggregateType;
     this.relationship = relationship;
     this.field = field;
@@ -7,7 +21,7 @@ export class AggregateProperty {
     this.resultType = aggregateType === 'avg' ? 'float' : 'number';
   }
 
-  compute(relatedRecords) {
+  compute(relatedRecords: AggregateRecord[]): number | null {
     if (!relatedRecords || !Array.isArray(relatedRecords) || relatedRecords.length === 0) {
       if (this.aggregateType === 'min' || this.aggregateType === 'max') return null;
       return 0;
@@ -19,7 +33,7 @@ export class AggregateProperty {
 
       case 'sum':
         return relatedRecords.reduce((acc, record) => {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
           return acc + (isNaN(val) ? 0 : val);
         }, 0);
 
@@ -27,7 +41,7 @@ export class AggregateProperty {
         let sum = 0;
         let count = 0;
         for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
           if (!isNaN(val)) {
             sum += val;
             count++;
@@ -37,18 +51,18 @@ export class AggregateProperty {
       }
 
       case 'min': {
-        let min = null;
+        let min: number | null = null;
         for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
           if (!isNaN(val) && (min === null || val < min)) min = val;
         }
         return min;
       }
 
       case 'max': {
-        let max = null;
+        let max: number | null = null;
         for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
           if (!isNaN(val) && (max === null || val > max)) max = val;
         }
         return max;
@@ -60,32 +74,32 @@ export class AggregateProperty {
   }
 }
 
-export function count(relationship) {
+export function count(relationship: string): AggregateProperty {
   return new AggregateProperty('count', relationship);
 }
 
-export function avg(relationshipOrField, field) {
+export function avg(relationshipOrField: string, field?: string): AggregateProperty {
   if (field !== undefined) {
     return new AggregateProperty('avg', relationshipOrField, field);
   }
   return new AggregateProperty('avg', undefined, relationshipOrField);
 }
 
-export function sum(relationshipOrField, field) {
+export function sum(relationshipOrField: string, field?: string): AggregateProperty {
   if (field !== undefined) {
     return new AggregateProperty('sum', relationshipOrField, field);
   }
   return new AggregateProperty('sum', undefined, relationshipOrField);
 }
 
-export function min(relationshipOrField, field) {
+export function min(relationshipOrField: string, field?: string): AggregateProperty {
   if (field !== undefined) {
     return new AggregateProperty('min', relationshipOrField, field);
   }
   return new AggregateProperty('min', undefined, relationshipOrField);
 }
 
-export function max(relationshipOrField, field) {
+export function max(relationshipOrField: string, field?: string): AggregateProperty {
   if (field !== undefined) {
     return new AggregateProperty('max', relationshipOrField, field);
   }

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

@@ -1,7 +1,7 @@
 import ModelProperty from './model-property.js';
 
-export default function attr() {
-  const modelProp = new ModelProperty(...arguments);
+export default function attr(type?: string, defaultValue?: unknown): ModelProperty {
+  const modelProp = new ModelProperty(type, defaultValue);
 
   return new Proxy(modelProp, {
     get(target, prop, receiver) {

package/src/belongs-to.ts

@@ -0,0 +1,90 @@
+import { createRecord, store } from '@stonyx/orm';
+import { getRelationships, getHasManyRegistry, getPendingRegistry, getPendingBelongsToRegistry } from './relationships.js';
+import type { SourceRecord } from './types/orm-types.js';
+
+function getOrSet<K, V>(map: Map<K, V>, key: K, defaultValue: V): V {
+  if (!map.has(key)) map.set(key, defaultValue);
+  return map.get(key)!;
+}
+
+interface BelongsToOptions {
+  _relationshipKey?: string;
+  [key: string]: unknown;
+}
+
+interface PendingBelongsToEntry {
+  sourceRecord: SourceRecord;
+  sourceModelName: string;
+  relationshipKey: string | undefined;
+  relationshipId: unknown;
+}
+
+type RelationshipHandler = ((sourceRecord: SourceRecord, rawData: unknown, options: BelongsToOptions) => unknown) & {
+  __relatedModelName: string;
+  __relationshipType: 'belongsTo';
+};
+
+export default function belongsTo(modelName: string): RelationshipHandler {
+  const hasManyRelationships = getHasManyRegistry();
+  const pendingHasManyQueue = getPendingRegistry();
+  const pendingBelongsToQueue = getPendingBelongsToRegistry();
+
+  const fn = (sourceRecord: SourceRecord, rawData: unknown, options: BelongsToOptions): unknown => {
+    if (!rawData) return null;
+
+    const { __name: sourceModelName } = sourceRecord.__model;
+    const relationshipId = sourceRecord.id;
+    const relationshipKey = options._relationshipKey;
+    const relationship = getRelationships('belongsTo', sourceModelName, modelName, relationshipId as string) as Map<unknown, unknown>;
+    const modelStore = store.get(modelName);
+
+    // Try to get existing record
+    let output: unknown;
+
+    if (typeof rawData === 'object') {
+      output = createRecord(modelName, rawData as Record<string, unknown>, options);
+    } else if (modelStore) {
+      output = modelStore.get(rawData as number | string);
+    }
+
+    // If not found and is a string ID, register as pending
+    if (!output && typeof rawData !== 'object') {
+      const targetId = rawData;
+
+      // Register pending belongsTo
+      const modelPendingMap = getOrSet(pendingBelongsToQueue, modelName, new Map());
+      const targetPendingArray = getOrSet(modelPendingMap, targetId, []);
+
+      targetPendingArray.push({
+        sourceRecord,
+        sourceModelName,
+        relationshipKey,
+        relationshipId
+      });
+
+      relationship.set(relationshipId, null);
+      return null;
+    }
+
+    relationship.set(relationshipId, output || {});
+
+    // Populate hasMany side if the relationship is defined
+    const outputRecord = typeof output === 'object' && output !== null && 'id' in output ? output as SourceRecord : undefined;
+    const otherSide = outputRecord ? hasManyRelationships.get(modelName)?.get(sourceModelName)?.get(outputRecord.id) as unknown[] | undefined : undefined;
+
+    if (otherSide) {
+      otherSide.push(sourceRecord);
+
+      // Remove pending queue if it was just fulfilled
+      const pendingModelRelationships = pendingHasManyQueue.get(sourceModelName);
+
+      if (pendingModelRelationships) pendingModelRelationships.delete(relationshipId);
+    }
+
+    return output;
+  };
+
+  Object.defineProperty(fn, '__relatedModelName', { value: modelName });
+  Object.defineProperty(fn, '__relationshipType', { value: 'belongsTo' as const });
+  return fn as RelationshipHandler;
+}

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

@@ -13,17 +13,23 @@
  *   stonyx-orm delete <collection> <id>
  *
  * Configuration (environment variables):
- *   DB_MODE      — 'file' or 'directory' (default: 'directory')
- *   DB_PATH      — Path to db.json (default: 'db.json')
- *   DB_DIRECTORY  — Directory name for collection files (default: 'db')
+ *   DB_MODE      -- 'file' or 'directory' (default: 'directory')
+ *   DB_PATH      -- Path to db.json (default: 'db.json')
+ *   DB_DIRECTORY  -- Directory name for collection files (default: 'db')
  *
  * Configuration (CLI flag):
- *   --config <path>  — Path to a JSON config file with { mode, dbPath, directory }
+ *   --config <path>  -- Path to a JSON config file with { mode, dbPath, directory }
  */
 
 import StandaloneDB from './standalone-db.js';
 import fs from 'fs/promises';
 
+interface CLIConfig {
+  mode: 'file' | 'directory';
+  dbPath: string;
+  directory: string;
+}
+
 const USAGE = `Usage: stonyx-orm <command> [options]
 
 Commands:
@@ -41,8 +47,8 @@ Environment variables:
   DB_PATH       Path to db.json (default: 'db.json')
   DB_DIRECTORY  Directory name for collection files (default: 'db')`;
 
-async function loadConfig(args) {
-  const config = {};
+async function loadConfig(args: string[]): Promise<CLIConfig> {
+  const config: Record<string, string> = {};
 
   // Check for --config flag
   const configIndex = args.indexOf('--config');
@@ -54,7 +60,7 @@ async function loadConfig(args) {
       const content = await fs.readFile(configPath, 'utf-8');
       Object.assign(config, JSON.parse(content));
     } catch (err) {
-      console.error(`Error reading config file '${configPath}': ${err.message}`);
+      console.error(`Error reading config file '${configPath}': ${err instanceof Error ? err.message : String(err)}`);
       process.exit(1);
     }
 
@@ -64,13 +70,13 @@ async function loadConfig(args) {
 
   // Environment variables override config file, config file overrides defaults
   return {
-    mode: process.env.DB_MODE || config.mode || 'directory',
+    mode: (process.env.DB_MODE || config.mode || 'directory') as 'file' | 'directory',
     dbPath: process.env.DB_PATH || config.dbPath || 'db.json',
     directory: process.env.DB_DIRECTORY || config.directory || 'db',
   };
 }
 
-function parseArgs(argv) {
+function parseArgs(argv: string[]): string[] {
   // Strip node binary and script path
   const args = argv.slice(2);
 
@@ -82,7 +88,7 @@ function parseArgs(argv) {
   return args;
 }
 
-async function run() {
+async function run(): Promise<void> {
   const args = parseArgs(process.argv);
   const config = await loadConfig(args);
   const db = new StandaloneDB(config);
@@ -169,7 +175,7 @@ async function run() {
         process.exit(1);
     }
   } catch (err) {
-    console.error(`Error: ${err.message}`);
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
 }