@stonyx/orm 0.2.1-beta.80 → 0.2.1-beta.82

package/src/postgres/schema-introspector.js

@@ -0,0 +1,354 @@
+import Orm from '@stonyx/orm';
+import { getPgType, getVectorType } from './type-map.js';
+import { camelCaseToKebabCase } from '@stonyx/utils/string';
+import { getPluralName } from '../plural-registry.js';
+import { dbKey } from '../db.js';
+import { AggregateProperty } from '../aggregates.js';
+
+function getRelationshipInfo(property) {
+  if (typeof property !== 'function') return null;
+  const fnStr = property.toString();
+  const modelName = property.__relatedModelName || null;
+
+  if (fnStr.includes(`getRelationships('belongsTo',`)) return { type: 'belongsTo', modelName };
+  if (fnStr.includes(`getRelationships('hasMany',`)) return { type: 'hasMany', modelName };
+
+  return null;
+}
+
+function sanitizeTableName(name) {
+  return name.replace(/[-/]/g, '_');
+}
+
+export function introspectModels() {
+  const { models } = Orm.instance;
+  const schemas = {};
+
+  for (const [modelKey, modelClass] of Object.entries(models)) {
+    const name = camelCaseToKebabCase(modelKey.slice(0, -5));
+
+    if (name === dbKey) continue;
+
+    const model = new modelClass(modelKey);
+    const columns = {};
+    const foreignKeys = {};
+    const relationships = { belongsTo: {}, hasMany: {} };
+    const vectorColumns = {};
+    let idType = 'number';
+
+    const transforms = Orm.instance.transforms;
+
+    for (const [key, property] of Object.entries(model)) {
+      if (key.startsWith('__')) continue;
+
+      const relInfo = getRelationshipInfo(property);
+
+      if (relInfo?.type === 'belongsTo') {
+        relationships.belongsTo[key] = relInfo.modelName;
+      } else if (relInfo?.type === 'hasMany') {
+        relationships.hasMany[key] = relInfo.modelName;
+      } else if (property?.constructor?.name === 'ModelProperty') {
+        if (key === 'id') {
+          idType = property.type;
+        } else if (property.type === 'vector') {
+          const dimensions = property.dimensions || 1536;
+          columns[key] = getVectorType(dimensions);
+          vectorColumns[key] = dimensions;
+        } else {
+          columns[key] = getPgType(property.type, transforms[property.type]);
+        }
+      }
+    }
+
+    // Build foreign keys from belongsTo relationships
+    for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
+      const fkColumn = `${relName}_id`;
+      foreignKeys[fkColumn] = {
+        references: sanitizeTableName(getPluralName(targetModelName)),
+        column: 'id',
+      };
+    }
+
+    schemas[name] = {
+      table: sanitizeTableName(getPluralName(name)),
+      idType,
+      columns,
+      foreignKeys,
+      relationships,
+      vectorColumns,
+      memory: modelClass.memory === true,
+    };
+  }
+
+  return schemas;
+}
+
+export function buildTableDDL(name, schema, allSchemas = {}) {
+  const { idType, columns, foreignKeys } = schema;
+  const table = sanitizeTableName(schema.table);
+  const lines = [];
+
+  // Primary key
+  if (idType === 'string') {
+    lines.push('  "id" VARCHAR(255) PRIMARY KEY');
+  } else {
+    lines.push('  "id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY');
+  }
+
+  // Attribute columns
+  for (const [col, pgType] of Object.entries(columns)) {
+    lines.push(`  "${col}" ${pgType}`);
+  }
+
+  // Foreign key columns
+  for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
+    const refIdType = getReferencedIdType(fkDef.references, allSchemas);
+    lines.push(`  "${fkCol}" ${refIdType}`);
+  }
+
+  // Timestamps
+  lines.push('  "created_at" TIMESTAMPTZ DEFAULT NOW()');
+  lines.push('  "updated_at" TIMESTAMPTZ DEFAULT NOW()');
+
+  // Foreign key constraints
+  for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
+    const refTable = sanitizeTableName(fkDef.references);
+    lines.push(`  FOREIGN KEY ("${fkCol}") REFERENCES "${refTable}"("${fkDef.column}") ON DELETE SET NULL`);
+  }
+
+  return `CREATE TABLE IF NOT EXISTS "${table}" (\n${lines.join(',\n')}\n)`;
+}
+
+/**
+ * Build HNSW index DDL for vector columns on a model.
+ * @param {string} name - Model name
+ * @param {Object} schema - Model schema with vectorColumns
+ * @returns {string[]} Array of CREATE INDEX statements
+ */
+export function buildVectorIndexDDL(name, schema) {
+  const table = sanitizeTableName(schema.table);
+  const statements = [];
+
+  for (const [col] of Object.entries(schema.vectorColumns || {})) {
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS "idx_${table}_${col}_hnsw" ON "${table}" USING hnsw ("${col}" vector_cosine_ops) WITH (m = 16, ef_construction = 200)`
+    );
+  }
+
+  return statements;
+}
+
+function getReferencedIdType(tableName, allSchemas) {
+  for (const schema of Object.values(allSchemas)) {
+    if (schema.table === tableName) {
+      return schema.idType === 'string' ? 'VARCHAR(255)' : 'INTEGER';
+    }
+  }
+
+  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)) {
+      visit(targetModelName);
+    }
+
+    order.push(name);
+  }
+
+  for (const name of Object.keys(schemas)) {
+    visit(name);
+  }
+
+  return order;
+}
+
+export function introspectViews() {
+  const orm = Orm.instance;
+  if (!orm.views) return {};
+
+  const schemas = {};
+
+  for (const [viewKey, viewClass] of Object.entries(orm.views)) {
+    const name = camelCaseToKebabCase(viewKey.slice(0, -4)); // Remove 'View' suffix
+
+    const source = viewClass.source;
+    if (!source) continue;
+
+    const model = new viewClass(name);
+    const columns = {};
+    const foreignKeys = {};
+    const aggregates = {};
+    const relationships = { belongsTo: {}, hasMany: {} };
+
+    for (const [key, property] of Object.entries(model)) {
+      if (key.startsWith('__')) continue;
+      if (key === 'id') continue;
+
+      if (property instanceof AggregateProperty) {
+        aggregates[key] = property;
+        continue;
+      }
+
+      const relInfo = getRelationshipInfo(property);
+
+      if (relInfo?.type === 'belongsTo') {
+        relationships.belongsTo[key] = relInfo.modelName;
+        const fkColumn = `${key}_id`;
+        foreignKeys[fkColumn] = {
+          references: sanitizeTableName(getPluralName(relInfo.modelName)),
+          column: 'id',
+        };
+      } else if (relInfo?.type === 'hasMany') {
+        relationships.hasMany[key] = relInfo.modelName;
+      } else if (property?.constructor?.name === 'ModelProperty') {
+        const transforms = Orm.instance.transforms;
+        columns[key] = getPgType(property.type, transforms[property.type]);
+      }
+    }
+
+    schemas[name] = {
+      viewName: sanitizeTableName(getPluralName(name)),
+      source,
+      groupBy: viewClass.groupBy || undefined,
+      columns,
+      foreignKeys,
+      aggregates,
+      relationships,
+      isView: true,
+      memory: viewClass.memory !== false ? false : false, // Views default to memory:false
+    };
+  }
+
+  return schemas;
+}
+
+export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
+  if (!viewSchema.source) {
+    throw new Error(`View '${name}' must define a source model`);
+  }
+
+  const sourceModelName = viewSchema.source;
+  const sourceSchema = modelSchemas[sourceModelName];
+  const sourceTable = sanitizeTableName(sourceSchema
+    ? sourceSchema.table
+    : getPluralName(sourceModelName));
+
+  const selectColumns = [];
+  const joins = [];
+  const hasAggregates = Object.keys(viewSchema.aggregates || {}).length > 0;
+  const groupByField = viewSchema.groupBy;
+
+  // ID column: groupBy field or source table PK
+  if (groupByField) {
+    selectColumns.push(`"${sourceTable}"."${groupByField}" AS "id"`);
+  } else {
+    selectColumns.push(`"${sourceTable}"."id" AS "id"`);
+  }
+
+  // Aggregate columns
+  for (const [key, aggProp] of Object.entries(viewSchema.aggregates || {})) {
+    // Use pgFunction if available, fall back to mysqlFunction
+    const fn = aggProp.pgFunction || aggProp.mysqlFunction;
+
+    if (aggProp.relationship === undefined) {
+      // Field-level aggregate (groupBy views)
+      if (aggProp.aggregateType === 'count') {
+        selectColumns.push(`COUNT(*) AS "${key}"`);
+      } else {
+        selectColumns.push(`${fn}("${sourceTable}"."${aggProp.field}") AS "${key}"`);
+      }
+    } else {
+      // Relationship aggregate
+      const relName = aggProp.relationship;
+      const relTable = sanitizeTableName(getPluralName(relName));
+
+      if (aggProp.aggregateType === 'count') {
+        selectColumns.push(`${fn}("${relTable}"."id") AS "${key}"`);
+      } else {
+        const field = aggProp.field;
+        selectColumns.push(`${fn}("${relTable}"."${field}") AS "${key}"`);
+      }
+
+      // Add LEFT JOIN for the relationship if not already added
+      const joinKey = `${relTable}`;
+      if (!joins.find(j => j.table === joinKey)) {
+        const fkColumn = `${sourceModelName}_id`;
+        joins.push({
+          table: relTable,
+          condition: `"${relTable}"."${fkColumn}" = "${sourceTable}"."id"`
+        });
+      }
+    }
+  }
+
+  // Regular columns
+  for (const [key] of Object.entries(viewSchema.columns || {})) {
+    selectColumns.push(`"${sourceTable}"."${key}" AS "${key}"`);
+  }
+
+  // Build JOIN clauses
+  const joinClauses = joins.map(j =>
+    `LEFT JOIN "${j.table}" ON ${j.condition}`
+  ).join('\n  ');
+
+  // Build GROUP BY
+  let groupBy = '';
+  if (groupByField) {
+    groupBy = `\nGROUP BY "${sourceTable}"."${groupByField}"`;
+  } else if (hasAggregates) {
+    groupBy = `\nGROUP BY "${sourceTable}"."id"`;
+  }
+
+  const viewName = sanitizeTableName(viewSchema.viewName);
+  const sql = `CREATE OR REPLACE VIEW "${viewName}" AS\nSELECT\n  ${selectColumns.join(',\n  ')}\nFROM "${sourceTable}"${joinClauses ? '\n  ' + joinClauses : ''}${groupBy}`;
+
+  return sql;
+}
+
+export function viewSchemasToSnapshot(viewSchemas) {
+  const snapshot = {};
+
+  for (const [name, schema] of Object.entries(viewSchemas)) {
+    snapshot[name] = {
+      viewName: schema.viewName,
+      source: schema.source,
+      ...(schema.groupBy ? { groupBy: schema.groupBy } : {}),
+      columns: { ...schema.columns },
+      foreignKeys: { ...schema.foreignKeys },
+      isView: true,
+      viewQuery: buildViewDDL(name, schema),
+    };
+  }
+
+  return snapshot;
+}
+
+export function schemasToSnapshot(schemas) {
+  const snapshot = {};
+
+  for (const [name, schema] of Object.entries(schemas)) {
+    snapshot[name] = {
+      table: schema.table,
+      idType: schema.idType,
+      columns: { ...schema.columns },
+      foreignKeys: { ...schema.foreignKeys },
+      ...(schema.vectorColumns && Object.keys(schema.vectorColumns).length > 0
+        ? { vectorColumns: { ...schema.vectorColumns } }
+        : {}),
+    };
+  }
+
+  return snapshot;
+}

package/src/postgres/type-map.js

@@ -0,0 +1,53 @@
+const typeMap = {
+  string: 'VARCHAR(255)',
+  number: 'INTEGER',
+  float: 'REAL',
+  boolean: 'BOOLEAN',
+  date: 'TIMESTAMPTZ',
+  timestamp: 'BIGINT',
+  passthrough: 'TEXT',
+  trim: 'VARCHAR(255)',
+  uppercase: 'VARCHAR(255)',
+  ceil: 'INTEGER',
+  floor: 'INTEGER',
+  round: 'INTEGER',
+};
+
+/**
+ * Resolves a Stonyx ORM attribute type to a PostgreSQL column type.
+ *
+ * For built-in types, returns the mapped PostgreSQL type directly.
+ *
+ * For custom transforms (e.g. an `animal` transform that maps strings to ints):
+ *   - If the transform function exports a `pgType` property, that value is used.
+ *   - Otherwise, if `mysqlType` is defined, it is mapped to a PG equivalent.
+ *   - Otherwise, defaults to JSONB. Values are JSON-stringified on write and
+ *     JSON-parsed on read by PostgreSQL natively.
+ */
+export function getPgType(attrType, transformFn) {
+  if (typeMap[attrType]) return typeMap[attrType];
+  if (transformFn?.pgType) return transformFn.pgType;
+  if (transformFn?.mysqlType) return mysqlTypeToPg(transformFn.mysqlType);
+
+  return 'JSONB';
+}
+
+/**
+ * Returns a vector column type for the given dimensions.
+ * @param {number} dimensions - Vector dimensionality (e.g. 768, 1536)
+ * @returns {string}
+ */
+export function getVectorType(dimensions) {
+  return `vector(${dimensions})`;
+}
+
+function mysqlTypeToPg(mysqlType) {
+  const upper = mysqlType.toUpperCase();
+  if (upper === 'TINYINT(1)') return 'BOOLEAN';
+  if (upper === 'INT' || upper === 'INT AUTO_INCREMENT') return 'INTEGER';
+  if (upper === 'DATETIME') return 'TIMESTAMPTZ';
+  if (upper === 'JSON') return 'JSONB';
+  return mysqlType;
+}
+
+export default typeMap;

package/src/store.js

@@ -22,15 +22,15 @@ export default class Store {
   }
 
   /**
-   * Async authoritative read. Always queries MySQL for memory: false models.
+   * Async authoritative read. Always queries the SQL database for memory: false models.
    * For memory: true models, returns from store (already loaded on boot).
    * @param {string} modelName - The model name
    * @param {string|number} id - The record ID
    * @returns {Promise<Record|undefined>}
    */
   async find(modelName, id) {
-    // For views in non-MySQL mode, use view resolver
-    if (Orm.instance?.isView?.(modelName) && !this._mysqlDb) {
+    // For views in non-SQL mode, use view resolver
+    if (Orm.instance?.isView?.(modelName) && !this._sqlDb) {
       const resolver = new ViewResolver(modelName);
       return resolver.resolveOne(id);
     }
@@ -40,12 +40,12 @@ export default class Store {
       return this.get(modelName, id);
     }
 
-    // For memory: false models, always query MySQL
-    if (this._mysqlDb) {
-      return this._mysqlDb.findRecord(modelName, id);
+    // For memory: false models, always query the SQL database
+    if (this._sqlDb) {
+      return this._sqlDb.findRecord(modelName, id);
     }
 
-    // Fallback to store (JSON mode or no MySQL)
+    // Fallback to store (JSON mode or no SQL adapter)
     return this.get(modelName, id);
   }
 
@@ -57,8 +57,8 @@ export default class Store {
    * @returns {Promise<Record[]>}
    */
   async findAll(modelName, conditions) {
-    // For views in non-MySQL mode, use view resolver
-    if (Orm.instance?.isView?.(modelName) && !this._mysqlDb) {
+    // For views in non-SQL mode, use view resolver
+    if (Orm.instance?.isView?.(modelName) && !this._sqlDb) {
       const resolver = new ViewResolver(modelName);
       const records = await resolver.resolveAll();
 
@@ -75,9 +75,9 @@ export default class Store {
       return modelStore ? Array.from(modelStore.values()) : [];
     }
 
-    // For memory: false models (or filtered queries), always query MySQL
-    if (this._mysqlDb) {
-      return this._mysqlDb.findAll(modelName, conditions);
+    // For memory: false models (or filtered queries), always query the SQL database
+    if (this._sqlDb) {
+      return this._sqlDb.findAll(modelName, conditions);
     }
 
     // Fallback to store (JSON mode) — apply conditions in-memory if provided
@@ -101,8 +101,8 @@ export default class Store {
    * @returns {Promise<Record[]>}
    */
   async query(modelName, conditions = {}) {
-    if (this._mysqlDb) {
-      return this._mysqlDb.findAll(modelName, conditions);
+    if (this._sqlDb) {
+      return this._sqlDb.findAll(modelName, conditions);
     }
 
     // Fallback: filter in-memory store
@@ -125,10 +125,10 @@ export default class Store {
   _memoryResolver = null;
 
   /**
-   * Set by Orm during init — reference to the MysqlDB instance for on-demand queries.
-   * @type {MysqlDB|null}
+   * Set by Orm during init — reference to the SQL adapter instance for on-demand queries.
+   * @type {object|null}
    */
-  _mysqlDb = null;
+  _sqlDb = null;
 
   /**
    * Check if a model is configured for in-memory storage.