@stonyx/orm 0.2.7-alpha.0 → 0.3.1

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

@@ -0,0 +1,153 @@
+import type { AggregateProperty } from '../aggregates.js';
+export interface OrmDbConfig {
+    file: string;
+    schema: string;
+    mode: string;
+    directory: string;
+    autosave: string;
+    saveInterval: string | number;
+}
+export interface OrmMysqlConfig {
+    host: string;
+    port?: number;
+    user: string;
+    password: string;
+    database: string;
+    connectionLimit?: number;
+    migrationsDir?: string;
+    migrationsTable?: string;
+    [key: string]: unknown;
+}
+export interface OrmPostgresConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    connectionLimit?: number;
+    migrationsDir?: string;
+    migrationsTable?: string;
+    [key: string]: unknown;
+}
+export interface OrmPaths {
+    model: string;
+    serializer: string;
+    transform: string;
+    view?: string;
+    access?: string;
+    [key: string]: string | undefined;
+}
+export interface OrmRestServerConfig {
+    enabled: string;
+    route: string;
+    metaRoute: boolean;
+}
+export interface OrmSection {
+    db: OrmDbConfig;
+    paths: OrmPaths;
+    restServer: OrmRestServerConfig;
+    mysql?: OrmMysqlConfig;
+    postgres?: OrmPostgresConfig;
+    timescale?: OrmPostgresConfig;
+    [key: string]: unknown;
+}
+export interface OrmConfig {
+    rootPath: string;
+    orm: OrmSection;
+    [key: string]: unknown;
+}
+export interface SourceRecord {
+    __model: {
+        __name: string;
+        [key: string]: unknown;
+    };
+    __data?: Record<string, unknown>;
+    __relationships?: Record<string, unknown>;
+    id: string | number;
+    [key: string]: unknown;
+}
+export interface OrmRecord {
+    id: string | number;
+    __model?: {
+        __name: string;
+    };
+    __data: Record<string, unknown> & {
+        id?: string | number;
+        __pendingSqlId?: boolean;
+    };
+    __relationships: Record<string, unknown>;
+    toJSON?(options?: {
+        fields?: Set<string>;
+        baseUrl?: string;
+    }): Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ForeignKeyDef {
+    references: string;
+    column: string;
+}
+export interface HypertableConfig {
+    timeColumn: string;
+    chunkInterval?: string;
+    compress?: {
+        segmentBy?: string;
+        orderBy?: string;
+        after?: string;
+    };
+}
+export interface ModelSchema {
+    table: string;
+    idType: string;
+    columns: Record<string, string>;
+    foreignKeys: Record<string, ForeignKeyDef>;
+    relationships: {
+        belongsTo: Record<string, string | null>;
+        hasMany: Record<string, string | null>;
+    };
+    vectorColumns?: Record<string, number>;
+    hypertable?: HypertableConfig;
+    memory: boolean;
+}
+export interface ViewSchema {
+    viewName: string;
+    source: string;
+    groupBy?: string;
+    columns: Record<string, string>;
+    foreignKeys: Record<string, ForeignKeyDef>;
+    aggregates: Record<string, AggregateProperty>;
+    relationships: {
+        belongsTo: Record<string, string | null>;
+        hasMany: Record<string, string | null>;
+    };
+    isView: boolean;
+    memory: boolean;
+}
+/**
+ * Typed relationship registry maps.
+ * Each key in Orm.relationships stores a different nested Map structure.
+ */
+/** Relationship registry map types — source → target → recordId → value */
+export type HasManyMap = Map<string, Map<string, Map<unknown, unknown[]>>>;
+export type BelongsToMap = Map<string, Map<string, Map<unknown, unknown>>>;
+export type GlobalMap = Map<string, unknown[][]>;
+export type PendingMap = Map<string, Map<unknown, unknown[][]>>;
+export type PendingBelongsToMap = Map<string, Map<unknown, unknown[]>>;
+export interface RelationshipMaps {
+    hasMany: HasManyMap;
+    belongsTo: BelongsToMap;
+    global: GlobalMap;
+    pending: PendingMap;
+    pendingBelongsTo: PendingBelongsToMap;
+}
+export interface SnapshotEntry {
+    table?: string;
+    idType?: string;
+    columns?: Record<string, string>;
+    foreignKeys?: Record<string, ForeignKeyDef>;
+    vectorColumns?: Record<string, number>;
+    hypertable?: HypertableConfig;
+    isView?: boolean;
+    viewName?: string;
+    source?: string;
+    viewQuery?: string;
+}

package/dist/types/orm-types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import type { OrmRecord } from './types/orm-types.js';
+export declare function isDbError(error: unknown): error is {
+    code: string;
+    message: string;
+};
+export declare function isOrmRecord(value: unknown): value is OrmRecord;
+export declare function pluralize(word: string): string;

package/dist/utils.js

@@ -0,0 +1,17 @@
+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';
+}
+export function isOrmRecord(value) {
+    return typeof value === 'object' && value !== null && '__data' in value && '__relationships' in value;
+}
+// Wrapper to handle dasherized model names (e.g., "access-link" → "access-links")
+export function pluralize(word) {
+    if (word.includes('-')) {
+        const parts = word.split('-');
+        const last = parts.pop();
+        const pluralizedLast = basePluralize(last);
+        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,171 @@
+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, []);
+            }
+            const group = groups.get(key);
+            if (group)
+                group.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,13 +4,38 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.7-alpha.0",
+  "version": "0.3.1",
   "description": "",
-  "main": "src/main.js",
+  "main": "dist/index.js",
   "type": "module",
+  "bin": {
+    "stonyx-orm": "./dist/cli.js"
+  },
   "exports": {
-    ".": "./src/index.js",
-    "./db": "./src/exports/db.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",
@@ -21,6 +46,12 @@
   "contributors": [
     "Stone Costa <stone.costa@synamicd.com>"
   ],
+  "files": [
+    "dist",
+    "src",
+    "config",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -30,17 +61,39 @@
   },
   "homepage": "https://github.com/abofs/stonyx-orm#readme",
   "dependencies": {
-    "stonyx": "^0.2.2",
-    "@stonyx/events": "^0.1.0",
-    "@stonyx/cron": "^0.2.0"
+    "@stonyx/cron": "0.2.1-beta.29",
+    "@stonyx/events": "0.1.1-beta.9",
+    "stonyx": "0.2.3-beta.11"
+  },
+  "peerDependencies": {
+    "@stonyx/rest-server": ">=0.2.1-beta.14",
+    "mysql2": "^3.0.0",
+    "pg": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "@stonyx/rest-server": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@stonyx/rest-server": "^0.2.0",
-    "@stonyx/utils": "^0.2.2",
+    "@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": "qunit --require ./stonyx-bootstrap.cjs"
+    "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.ts

@@ -0,0 +1,109 @@
+type AggregateType = 'count' | 'avg' | 'sum' | 'min' | 'max';
+
+interface AggregateRecord {
+  __data?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export class AggregateProperty {
+  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;
+    this.mysqlFunction = aggregateType.toUpperCase();
+    this.resultType = aggregateType === 'avg' ? 'float' : 'number';
+  }
+
+  compute(relatedRecords: AggregateRecord[]): number | null {
+    if (!relatedRecords || !Array.isArray(relatedRecords) || relatedRecords.length === 0) {
+      if (this.aggregateType === 'min' || this.aggregateType === 'max') return null;
+      return 0;
+    }
+
+    if (this.aggregateType === 'count') return relatedRecords.length;
+
+    const field = this.field;
+    if (!field) return null;
+
+    switch (this.aggregateType) {
+      case 'sum':
+        return relatedRecords.reduce((acc, record) => {
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
+          return acc + (isNaN(val) ? 0 : val);
+        }, 0);
+
+      case 'avg': {
+        let sum = 0;
+        let count = 0;
+        for (const record of relatedRecords) {
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
+          if (!isNaN(val)) {
+            sum += val;
+            count++;
+          }
+        }
+        return count === 0 ? 0 : sum / count;
+      }
+
+      case 'min': {
+        let min: number | null = null;
+        for (const record of relatedRecords) {
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
+          if (!isNaN(val) && (min === null || val < min)) min = val;
+        }
+        return min;
+      }
+
+      case 'max': {
+        let max: number | null = null;
+        for (const record of relatedRecords) {
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
+          if (!isNaN(val) && (max === null || val > max)) max = val;
+        }
+        return max;
+      }
+
+      default:
+        return null;
+    }
+  }
+}
+
+export function count(relationship: string): AggregateProperty {
+  return new AggregateProperty('count', relationship);
+}
+
+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: string, field?: string): AggregateProperty {
+  if (field !== undefined) {
+    return new AggregateProperty('sum', relationshipOrField, field);
+  }
+  return new AggregateProperty('sum', undefined, relationshipOrField);
+}
+
+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: string, field?: string): AggregateProperty {
+  if (field !== undefined) {
+    return new AggregateProperty('max', relationshipOrField, field);
+  }
+  return new AggregateProperty('max', undefined, relationshipOrField);
+}

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) {