@stonyx/orm 0.2.1-beta.87 → 0.2.1-beta.88

package/src/postgres/postgres-db.ts

@@ -122,7 +122,7 @@ export default class PostgresDB {
     const pending = files.filter(f => !applied.includes(f));
 
     if (pending.length > 0) {
-      this.deps.log.db!(`${pending.length} pending migration(s) found.`);
+      this.deps.log.db?.(`${pending.length} pending migration(s) found.`);
 
       const shouldApply = await this.deps.confirm(`${pending.length} pending migration(s) found. Apply now?`);
 
@@ -132,13 +132,13 @@ export default class PostgresDB {
           const { up } = this.deps.parseMigrationFile(content);
 
           await this.deps.applyMigration(this.requirePool(), filename, up, this.pgConfig.migrationsTable as string | undefined);
-          this.deps.log.db!(`Applied migration: ${filename}`);
+          this.deps.log.db?.(`Applied migration: ${filename}`);
         }
 
         // Reload records after applying migrations
         await this.loadMemoryRecords();
       } else {
-        this.deps.log.warn!('Skipping pending migrations. Schema may be outdated.');
+        this.deps.log.warn?.('Skipping pending migrations. Schema may be outdated.');
       }
     } else if (files.length === 0) {
       const schemas = this.deps.introspectModels();
@@ -156,11 +156,11 @@ export default class PostgresDB {
           if (result) {
             const { up } = this.deps.parseMigrationFile(result.content);
             await this.deps.applyMigration(this.requirePool(), result.filename, up, this.pgConfig.migrationsTable as string | undefined);
-            this.deps.log.db!(`Applied migration: ${result.filename}`);
+            this.deps.log.db?.(`Applied migration: ${result.filename}`);
             await this.loadMemoryRecords();
           }
         } else {
-          this.deps.log.warn!('Skipping initial migration. Tables may not exist.');
+          this.deps.log.warn?.('Skipping initial migration. Tables may not exist.');
         }
       }
     }
@@ -173,8 +173,8 @@ export default class PostgresDB {
       const drift = this.deps.detectSchemaDrift(schemas, snapshot as Parameters<typeof detectSchemaDrift>[1]);
 
       if (drift.hasChanges) {
-        this.deps.log.warn!('Schema drift detected: models have changed since the last migration.');
-        this.deps.log.warn!('Run `stonyx db:generate-migration` to create a new migration.');
+        this.deps.log.warn?.('Schema drift detected: models have changed since the last migration.');
+        this.deps.log.warn?.('Run `stonyx db:generate-migration` to create a new migration.');
       }
     }
   }
@@ -200,7 +200,7 @@ export default class PostgresDB {
     for (const modelName of order) {
       const { modelClass } = Orm.instance.getRecordClasses(modelName) as { modelClass: { memory?: boolean } };
       if (modelClass?.memory === false) {
-        this.deps.log.db!(`Skipping memory load for '${modelName}' (memory: false)`);
+        this.deps.log.db?.(`Skipping memory load for '${modelName}' (memory: false)`);
         continue;
       }
 
@@ -217,7 +217,7 @@ export default class PostgresDB {
       } catch (error) {
         // 42P01 = undefined_table (PG equivalent of ER_NO_SUCH_TABLE)
         if (isDbError(error) && error.code === '42P01') {
-          this.deps.log.db!(`Table '${schema.table}' does not exist yet. Skipping load for '${modelName}'.`);
+          this.deps.log.db?.(`Table '${schema.table}' does not exist yet. Skipping load for '${modelName}'.`);
           continue;
         }
 
@@ -231,7 +231,7 @@ export default class PostgresDB {
     for (const [viewName, viewSchema] of Object.entries(viewSchemas)) {
       const { modelClass: viewClass } = Orm.instance.getRecordClasses(viewName) as { modelClass: { memory?: boolean } };
       if (viewClass?.memory !== true) {
-        this.deps.log.db!(`Skipping memory load for view '${viewName}' (memory: false)`);
+        this.deps.log.db?.(`Skipping memory load for view '${viewName}' (memory: false)`);
         continue;
       }
 
@@ -256,7 +256,7 @@ export default class PostgresDB {
         }
       } catch (error) {
         if (isDbError(error) && error.code === '42P01') {
-          this.deps.log.db!(`View '${viewSchema.viewName}' does not exist yet. Skipping load for '${viewName}'.`);
+          this.deps.log.db?.(`View '${viewSchema.viewName}' does not exist yet. Skipping load for '${viewName}'.`);
           continue;
         }
         throw error;
@@ -345,13 +345,14 @@ export default class PostgresDB {
 
     if (!schema) return [];
 
-    const { sql, values } = this.deps.buildSelect(schema.table, conditions);
+    const resolvedSchema = schema;
+    const { sql, values } = this.deps.buildSelect(resolvedSchema.table, conditions);
 
     try {
       const result = await this.requirePool().query(sql, values);
 
       const records = result.rows.map(row => {
-        const rawData = this._rowToRawData(row, schema!);
+        const rawData = this._rowToRawData(row, resolvedSchema);
         return this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false }) as unknown as OrmRecord;
       });
 

package/src/postgres/schema-introspector.ts

@@ -93,9 +93,10 @@ export function introspectModels(): Record<string, ModelSchema> {
 
     // Build foreign keys from belongsTo relationships
     for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
+      if (!targetModelName) continue;
       const fkColumn = `${relName}_id`;
       foreignKeys[fkColumn] = {
-        references: sanitizeTableName(getPluralName(targetModelName!)),
+        references: sanitizeTableName(getPluralName(targetModelName)),
         column: 'id',
       };
     }
@@ -189,7 +190,7 @@ export function getTopologicalOrder(schemas: Record<string, ModelSchema>): strin
 
     // Visit dependencies (belongsTo targets) first
     for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-      visit(targetModelName!);
+      if (targetModelName) visit(targetModelName);
     }
 
     order.push(name);
@@ -233,11 +234,13 @@ export function introspectViews(): Record<string, ViewSchema> {
 
       if (relInfo?.type === 'belongsTo') {
         relationships.belongsTo[key] = relInfo.modelName;
-        const fkColumn = `${key}_id`;
-        foreignKeys[fkColumn] = {
-          references: sanitizeTableName(getPluralName(relInfo.modelName!)),
-          column: 'id',
-        };
+        if (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 instanceof ModelProperty) {

package/src/relationships.ts

@@ -13,11 +13,12 @@ export function getRelationships(type: string, sourceModel: string, targetModel:
   // 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)!;
+  const modelRelationship = allRelationships.get(sourceModel) as Map<string, Map<unknown, unknown>> | undefined;
+  if (!modelRelationship) return undefined;
 
   if (!modelRelationship.has(targetModel)) modelRelationship.set(targetModel, new Map());
 
-  const relationship = modelRelationship.get(targetModel)!;
+  const relationship = modelRelationship.get(targetModel) as Map<unknown, unknown> | undefined;
 
   // TODO: Determine whether already having id should be handled differently
   //if (relationship.has(relationshipId)) return;

package/src/setup-rest-server.ts

@@ -14,7 +14,7 @@ interface AccessInstance {
 }
 
 export default async function(route: string, accessPath: string, metaRoute: boolean): Promise<void> {
-  let accessFiles: Record<string, (request: unknown) => unknown> | null = {};
+  const accessFiles: Record<string, (request: unknown) => unknown> = {};
 
   try {
     await forEachFileImport(accessPath, (accessClass: unknown) => {
@@ -31,14 +31,14 @@ export default async function(route: string, accessPath: string, metaRoute: bool
       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 instanceof Error ? error.message : String(error));
-    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');
@@ -47,7 +47,7 @@ export default async function(route: string, accessPath: string, metaRoute: bool
   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 } });
@@ -55,11 +55,8 @@ export default async function(route: string, accessPath: string, metaRoute: bool
 
   // 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 });
   }
-
-  // Cleanup references
-  accessFiles = null;
 }

package/src/store.ts

@@ -332,7 +332,8 @@ export default class Store {
     }];
 
     while (queue.length > 0) {
-      const item = queue.shift()!;
+      const item = queue.shift();
+      if (!item) break;
       const key = `${item.modelName}:${item.recordId}`;
 
       if (visited.has(key)) continue;

package/src/utils.ts

@@ -8,7 +8,8 @@ export function isDbError(error: unknown): error is { code: string; message: str
 export function pluralize(word: string): string {
   if (word.includes('-')) {
     const parts = word.split('-');
-    const pluralizedLast = basePluralize(parts.pop()!);
+    const last = parts.pop() as string;
+    const pluralizedLast = basePluralize(last);
     return [...parts, pluralizedLast].join('-');
   }
 

package/src/view-resolver.ts

@@ -137,7 +137,8 @@ export default class ViewResolver {
       if (!groups.has(key)) {
         groups.set(key, []);
       }
-      groups.get(key)!.push(record);
+      const group = groups.get(key);
+      if (group) group.push(record);
     }
 
     const results: unknown[] = [];