@stonyx/orm 0.2.5-alpha.0 → 0.3.1

package/src/has-many.ts

@@ -0,0 +1,92 @@
+import { createRecord, store } from '@stonyx/orm';
+import { getRelationships, getGlobalRegistry, getPendingRegistry, getBelongsToRegistry } from './relationships.js';
+import { getOrSet, makeArray } from '@stonyx/utils/object';
+import { dbKey } from './db.js';
+import type { SourceRecord } from './types/orm-types.js';
+
+interface HasManyOptions {
+  global?: boolean;
+  [key: string]: unknown;
+}
+
+interface PendingItem {
+  pendingRelationship: Map<unknown, unknown[][]>;
+  id: unknown;
+}
+
+type RelationshipHandler = ((sourceRecord: SourceRecord, rawData: unknown, options: HasManyOptions) => unknown[]) & {
+  __relatedModelName: string;
+  __relationshipType: 'hasMany';
+};
+
+function queuePendingRelationship(
+  pendingRelationshipQueue: PendingItem[],
+  pendingRelationships: Map<string, Map<unknown, unknown[][]>>,
+  modelName: string,
+  id: unknown
+): null {
+  pendingRelationshipQueue.push({
+    pendingRelationship: getOrSet(pendingRelationships, modelName, new Map()),
+    id
+  });
+
+  return null;
+}
+
+export default function hasMany(modelName: string): RelationshipHandler {
+  const globalRelationships = getGlobalRegistry();
+  const pendingRelationships = getPendingRegistry();
+
+  const fn = (sourceRecord: SourceRecord, rawData: unknown, options: HasManyOptions): unknown[] => {
+    const { __name: sourceModelName } = sourceRecord.__model;
+    const relationshipId = sourceRecord.id;
+    const relationship = getRelationships('hasMany', sourceModelName, modelName, relationshipId as string) as Map<unknown, unknown[]>;
+    const modelStore = store.get(modelName);
+    const pendingRelationshipQueue: PendingItem[] = [];
+
+    const output: unknown[] = !rawData ? [] : makeArray(rawData).map((elementData: unknown) => {
+      let record: unknown;
+
+      if (typeof elementData !== 'object') {
+        if (!modelStore) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+
+        record = modelStore.get(elementData as number | string);
+
+        if (!record) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+      } else {
+        if (elementData !== Object(elementData)) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+
+        record = createRecord(modelName, elementData as Record<string, unknown>, options);
+      }
+
+      // Populate belongTo side if the relationship is defined
+      const recordWithId = typeof record === 'object' && record !== null && 'id' in record ? record as SourceRecord : undefined;
+      const otherSide = recordWithId ? getBelongsToRegistry()
+        .get(modelName)?.get(sourceModelName)?.get(recordWithId.id) : undefined;
+
+      if (otherSide) Object.assign(otherSide, sourceRecord);
+
+      return record;
+    }).filter((value: unknown) => value);
+
+    relationship.set(relationshipId, output);
+
+    // Assign global relationship
+    if (options.global || sourceModelName === dbKey) getOrSet(globalRelationships, modelName, []).push(output);
+
+    // Assign pending relationships
+    for (const { pendingRelationship, id } of pendingRelationshipQueue) getOrSet(pendingRelationship, id, []).push(output);
+
+    return output;
+  };
+
+  Object.defineProperty(fn, '__relatedModelName', { value: modelName });
+  Object.defineProperty(fn, '__relationshipType', { value: 'hasMany' as const });
+  return fn as RelationshipHandler;
+}

package/src/hooks.ts

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2025 Stone Costa
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Middleware-based hooks registry for ORM operations.
+ * Unlike event-based hooks, middleware hooks run sequentially and can halt operations.
+ */
+
+/** Context object passed to before/after hook handlers. */
+export interface HookContext {
+  /** Model name (e.g. 'user', 'animal'). */
+  model: string;
+  /** Operation name: 'create', 'update', 'delete', 'get', or 'list'. */
+  operation: string;
+  /** The incoming HTTP request object. */
+  request?: unknown;
+  /** URL route parameters (e.g. { id: '42' }). */
+  params?: Record<string, string>;
+  /** Parsed request body for create/update operations. */
+  body?: Record<string, unknown>;
+  /** URL query string parameters. */
+  query?: Record<string, string>;
+  /** Mutable state bag shared across hooks within a single request. */
+  state?: Record<string, unknown>;
+  /** Previous record state (available in update hooks). */
+  oldState?: unknown;
+  /** Target record ID for single-record operations. */
+  recordId?: string | number;
+  /** Response data (available in after hooks). */
+  response?: unknown;
+  /** The affected record (available in after hooks for create/update/delete). */
+  record?: unknown;
+  /** The affected records (available in after hooks for list operations). */
+  records?: unknown[];
+  [key: string]: unknown;
+}
+
+type HookHandler = (context: HookContext) => unknown | Promise<unknown>;
+
+// Map of "operation:model" -> handler[]
+const beforeHooks: Map<string, HookHandler[]> = new Map();
+const afterHooks: Map<string, HookHandler[]> = new Map();
+
+/**
+ * Register a before hook middleware that runs before the operation executes.
+ *
+ * @param operation - Operation name: 'create', 'update', 'delete', 'get', or 'list'
+ * @param model - Model name (e.g., 'user', 'animal')
+ * @param handler - Middleware function (context) => any
+ *   - Return undefined to continue to next hook/handler
+ *   - Return any value to halt operation (integer = HTTP status, object = response body)
+ * @returns Unsubscribe function
+ */
+export function beforeHook(operation: string, model: string, handler: HookHandler): () => void {
+  const key = `${operation}:${model}`;
+  if (!beforeHooks.has(key)) {
+    beforeHooks.set(key, []);
+  }
+  const hooks = beforeHooks.get(key);
+  if (hooks) hooks.push(handler);
+
+  // Return unsubscribe function
+  return () => {
+    const hooks = beforeHooks.get(key);
+    if (hooks) {
+      const index = hooks.indexOf(handler);
+      if (index > -1) hooks.splice(index, 1);
+    }
+  };
+}
+
+/**
+ * Register an after hook middleware that runs after the operation completes.
+ * After hooks cannot halt operations (they run after completion).
+ *
+ * @param operation - Operation name
+ * @param model - Model name
+ * @param handler - Middleware function (context) => void
+ * @returns Unsubscribe function
+ */
+export function afterHook(operation: string, model: string, handler: HookHandler): () => void {
+  const key = `${operation}:${model}`;
+  if (!afterHooks.has(key)) {
+    afterHooks.set(key, []);
+  }
+  const hooks = afterHooks.get(key);
+  if (hooks) hooks.push(handler);
+
+  // Return unsubscribe function
+  return () => {
+    const hooks = afterHooks.get(key);
+    if (hooks) {
+      const index = hooks.indexOf(handler);
+      if (index > -1) hooks.splice(index, 1);
+    }
+  };
+}
+
+/**
+ * Get all before hooks for an operation:model combination.
+ */
+export function getBeforeHooks(operation: string, model: string): HookHandler[] {
+  const key = `${operation}:${model}`;
+  return beforeHooks.get(key) || [];
+}
+
+/**
+ * Get all after hooks for an operation:model combination.
+ */
+export function getAfterHooks(operation: string, model: string): HookHandler[] {
+  const key = `${operation}:${model}`;
+  return afterHooks.get(key) || [];
+}
+
+/**
+ * Clear registered hooks for a specific operation:model.
+ *
+ * @param operation - Operation name
+ * @param model - Model name
+ * @param type - 'before' or 'after' (if omitted, clears both)
+ */
+export function clearHook(operation: string, model: string, type?: 'before' | 'after'): void {
+  const key = `${operation}:${model}`;
+  if (!type || type === 'before') {
+    beforeHooks.set(key, []);
+  }
+  if (!type || type === 'after') {
+    afterHooks.set(key, []);
+  }
+}
+
+/**
+ * Clear all hooks (useful for testing).
+ */
+export function clearAllHooks(): void {
+  beforeHooks.clear();
+  afterHooks.clear();
+}

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

@@ -15,14 +15,24 @@
  */
 
 import Model from './model.js';
+import View from './view.js';
 import Serializer from './serializer.js';
 
 import attr from './attr.js';
 import belongsTo from './belongs-to.js';
 import hasMany from './has-many.js';
 import { createRecord, updateRecord } from './manage-record.js';
+import { count, avg, sum, min, max } from './aggregates.js';
 
 export { default } from './main.js';
 export { store, relationships } from './main.js';
-export { Model, Serializer }; // base classes
-export { attr, belongsTo, hasMany, createRecord, updateRecord }; // helpers
+export { Model, View, Serializer }; // base classes
+export { attr, belongsTo, hasMany, createRecord, updateRecord }; // helpers
+export { count, avg, sum, min, max }; // aggregate helpers
+export { beforeHook, afterHook, clearHook, clearAllHooks } from './hooks.js'; // middleware hooks
+
+// Store API:
+// store.get(model, id)   -- sync, memory-only
+// store.find(model, id)  -- async, MySQL for memory:false models
+// store.findAll(model)   -- async, all records
+// store.query(model, conditions) -- async, always hits MySQL

package/src/main.ts

@@ -0,0 +1,229 @@
+/*
+ * Copyright 2025 Stone Costa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import DB from './db.js';
+import config from 'stonyx/config';
+import log from 'stonyx/log';
+import { forEachFileImport } from '@stonyx/utils/file';
+import { kebabCaseToPascalCase, pluralize } from '@stonyx/utils/string';
+import { registerPluralName } from './plural-registry.js';
+import setupRestServer from './setup-rest-server.js';
+import baseTransforms from './transforms.js';
+import Store from './store.js';
+import Serializer from './serializer.js';
+import { setup } from '@stonyx/events';
+
+interface OrmOptions {
+  dbType?: string;
+}
+
+export interface SqlDb {
+  init(): Promise<unknown>;
+  startup(): Promise<void>;
+  shutdown(): Promise<void>;
+  persist(operation: string, model: string, context: unknown, response: unknown): Promise<void>;
+  findRecord(modelName: string, id: unknown): Promise<unknown>;
+  findAll(modelName: string, conditions?: Record<string, unknown>): Promise<unknown[]>;
+}
+
+export interface OrmDB {
+  record: unknown;
+  save(): Promise<void>;
+  init(): Promise<void>;
+}
+
+const defaultOptions: OrmOptions = {
+  dbType: 'json'
+}
+
+export default class Orm {
+  static initialized: boolean = false;
+  static relationships: Map<string, Map<string, unknown>> = new Map();
+  static store: Store = new Store();
+  static instance: Orm;
+  static ready: unknown[];
+
+  models: Record<string, unknown> = {};
+  serializers: Record<string, unknown> = {};
+  views: Record<string, unknown> = {};
+  transforms: Record<string, (value: unknown) => unknown> = { ...baseTransforms };
+  warnings: Set<string> = new Set();
+  options!: OrmOptions;
+  sqlDb?: SqlDb;
+  db?: OrmDB | SqlDb;
+
+  constructor(options: OrmOptions = {}) {
+    if (Orm.instance) return Orm.instance;
+
+    const { relationships } = Orm;
+
+    // Declare relationship maps
+    for (const key of ['hasMany', 'belongsTo', 'global', 'pending', 'pendingBelongsTo']) {
+      relationships.set(key, new Map());
+    }
+
+    this.options = { ...defaultOptions, ...options };
+
+    Orm.instance = this;
+  }
+
+  async init(): Promise<void> {
+    const { paths, restServer } = config.orm;
+
+    const promises: Promise<unknown>[] = ['Model', 'Serializer', 'Transform'].map(type => {
+      const lowerCaseType = type.toLowerCase();
+      const path = paths[lowerCaseType];
+
+      if (!path) throw new Error(`Configuration Error: ORM path for "${type}" must be defined.`);
+
+      return forEachFileImport(path, (exported: unknown, { name }: { name: string }) => {
+        // Transforms keep their original name, everything else gets converted to PascalCase with the type suffix
+        const alias = type === 'Transform' ? name : `${kebabCaseToPascalCase(name)}${type}`;
+
+        if (type === 'Model') {
+          Orm.store.set(name, new Map());
+          registerPluralName(name, exported as { pluralName?: string });
+        }
+
+        const collection = this[pluralize(lowerCaseType) as keyof this] as Record<string, unknown>;
+        return collection[alias] = exported;
+      }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
+    });
+
+    // Wait for imports before db & rest server setup
+    await Promise.all(promises);
+
+    // Discover views from paths.view (separate from model/serializer/transform)
+    if (paths.view) {
+      await forEachFileImport(paths.view, (exported: unknown, { name }: { name: string }) => {
+        const alias = `${kebabCaseToPascalCase(name)}View`;
+        Orm.store.set(name, new Map());
+        registerPluralName(name, exported as { pluralName?: string });
+        this.views[alias] = exported;
+      }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
+    }
+
+    // Setup event names for hooks after models are loaded
+    const eventNames: string[] = [];
+    const operations = ['list', 'get', 'create', 'update', 'delete'];
+    const viewOperations = ['list', 'get'];
+    const timings = ['before', 'after'];
+
+    for (const modelName of Orm.store.data.keys()) {
+      const isView = this.isView(modelName);
+      const ops = isView ? viewOperations : operations;
+
+      for (const timing of timings) {
+        for (const operation of ops) {
+          eventNames.push(`${timing}:${operation}:${modelName}`);
+        }
+      }
+    }
+
+    setup(eventNames);
+
+    if (config.orm.timescale) {
+      const { default: TimescaleDB } = await import('./timescale/timescale-db.js');
+      this.sqlDb = new TimescaleDB() as SqlDb;
+      this.db = this.sqlDb;
+      promises.push(this.sqlDb.init());
+    } else if (config.orm.postgres) {
+      const { default: PostgresDB } = await import('./postgres/postgres-db.js');
+      this.sqlDb = new PostgresDB() as SqlDb;
+      this.db = this.sqlDb;
+      promises.push(this.sqlDb.init());
+    } else if (config.orm.mysql) {
+      const { default: MysqlDB } = await import('./mysql/mysql-db.js');
+      this.sqlDb = new MysqlDB() as SqlDb;
+      this.db = this.sqlDb;
+      promises.push(this.sqlDb.init());
+    } else if (this.options.dbType !== 'none') {
+      const db = new DB();
+      this.db = db;
+
+      promises.push(db.init());
+    }
+
+    if (restServer.enabled === 'true') {
+      promises.push(setupRestServer(restServer.route, paths.access, restServer.metaRoute));
+    }
+
+    // Wire up memory resolver so store.find() can check model memory flags
+    Orm.store._memoryResolver = (modelName: string): boolean => {
+      const { modelClass } = this.getRecordClasses(modelName);
+      return (modelClass as { memory?: boolean })?.memory === true;
+    };
+
+    // Wire up SQL adapter reference for on-demand queries from store.find()/findAll()
+    if (this.sqlDb) {
+      Orm.store._sqlDb = this.sqlDb;
+    }
+
+    Orm.ready = await Promise.all(promises);
+    Orm.initialized = true;
+  }
+
+  async startup(): Promise<void> {
+    if (this.sqlDb) await this.sqlDb.startup();
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.sqlDb) await this.sqlDb.shutdown();
+  }
+
+  static get db(): OrmDB | SqlDb {
+    if (!Orm.initialized) throw new Error('ORM has not been initialized yet');
+
+    if (!Orm.instance.db) throw new Error('ORM database has not been initialized');
+    return Orm.instance.db;
+  }
+
+  getRecordClasses(modelName: string): { modelClass: unknown; serializerClass: unknown } {
+    const modelClassPrefix = kebabCaseToPascalCase(modelName);
+
+    // Check views first, then models
+    const viewClass = this.views[`${modelClassPrefix}View`];
+    if (viewClass) {
+      return {
+        modelClass: viewClass,
+        serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
+      };
+    }
+
+    return {
+      modelClass: this.models[`${modelClassPrefix}Model`],
+      serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
+    };
+  }
+
+  isView(modelName: string): boolean {
+    const modelClassPrefix = kebabCaseToPascalCase(modelName);
+    return !!this.views[`${modelClassPrefix}View`];
+  }
+
+  // Queue warnings to avoid the same error from being logged in the same iteration
+  warn(message: string): void {
+    this.warnings.add(message);
+
+    setTimeout(() => {
+      this.warnings.forEach(warning => log.warn?.(warning));
+      this.warnings.clear();
+    }, 0);
+  }
+}
+
+export const store = Orm.store;
+export const relationships = Orm.relationships;

package/src/manage-record.ts

@@ -0,0 +1,161 @@
+import Orm, { store } from '@stonyx/orm';
+import OrmRecord from './record.js';
+import { getGlobalRegistry, getPendingRegistry, getPendingBelongsToRegistry, getBelongsToRegistry, getHasManyRegistry } from './relationships.js';
+import type Serializer from './serializer.js';
+import { isOrmRecord } from './utils.js';
+
+interface CreateRecordOptions {
+  isDbRecord?: boolean;
+  serialize?: boolean;
+  transform?: boolean;
+  update?: boolean;
+  [key: string]: unknown;
+}
+
+interface PendingBelongsToEntry {
+  sourceRecord: OrmRecord;
+  sourceModelName: string;
+  relationshipKey: string;
+  relationshipId: unknown;
+}
+
+const defaultOptions: CreateRecordOptions = {
+  isDbRecord: false,
+  serialize: true,
+  transform: true
+};
+
+export function createRecord(modelName: string, rawData: { [key: string]: unknown } = {}, userOptions: CreateRecordOptions = {}): OrmRecord {
+  const orm = Orm.instance;
+  const { initialized } = Orm;
+  const options = { ...defaultOptions, ...userOptions };
+
+  if (!initialized && !options.isDbRecord) throw new Error('ORM is not ready');
+
+  // Guard: read-only views cannot have records created directly
+  if (orm?.isView?.(modelName) && !options.isDbRecord) {
+    throw new Error(`Cannot create records for read-only view '${modelName}'`);
+  }
+
+  const modelStore = store.get(modelName);
+  const globalRelationships = getGlobalRegistry();
+  const pendingRelationships = getPendingRegistry();
+
+  if (!modelStore) throw new Error(`Model store for '${modelName}' is not registered. Ensure the model is defined before creating records.`);
+
+  assignRecordId(modelName, rawData);
+  const existingRecord = modelStore.get(rawData.id as number | string);
+
+  if (existingRecord instanceof OrmRecord) {
+    // Update the existing record with new data so the last entry wins
+    updateRecord(existingRecord, rawData, { ...options, update: true });
+    return existingRecord;
+  }
+
+  const recordClasses = orm.getRecordClasses(modelName);
+  const modelClass = recordClasses.modelClass as (new (name: string) => { __name: string; [key: string]: unknown }) | undefined;
+  const serializerClass = recordClasses.serializerClass as new (model: { [key: string]: unknown }) => Serializer;
+
+  if (!modelClass) throw new Error(`A model named '${modelName}' does not exist`);
+
+  const model = new modelClass(modelName);
+  const serializer = new serializerClass(model);
+  const record = new OrmRecord(model, serializer);
+
+  record.serialize(rawData, options);
+  modelStore.set(record.id as number | string, record);
+
+  // populate global hasMany relationships
+  const globalHasMany = globalRelationships.get(modelName);
+  if (globalHasMany) for (const relationship of globalHasMany) relationship.push(record);
+
+  // populate pending hasMany relationships and clear the queue
+  const pendingHasMany = pendingRelationships.get(modelName)?.get(record.id);
+  if (pendingHasMany) {
+    for (const relationship of pendingHasMany) relationship.push(record);
+    pendingHasMany.splice(0);
+  }
+
+  // Fulfill pending belongsTo relationships
+  const pendingBelongsToQueue = getPendingBelongsToRegistry();
+  const pendingBelongsToRaw = pendingBelongsToQueue.get(modelName)?.get(record.id);
+  const pendingBelongsTo = Array.isArray(pendingBelongsToRaw) ? pendingBelongsToRaw as PendingBelongsToEntry[] : undefined;
+
+  if (pendingBelongsTo) {
+    const belongsToReg = getBelongsToRegistry();
+    const hasManyReg = getHasManyRegistry();
+
+    for (const { sourceRecord, sourceModelName, relationshipKey, relationshipId } of pendingBelongsTo) {
+      // Update the belongsTo relationship on the source record
+      sourceRecord.__relationships[relationshipKey] = record;
+      sourceRecord[relationshipKey] = record; // Also update the direct property
+
+      // Update the belongsTo relationship registry
+      const sourceModelReg = belongsToReg.get(sourceModelName);
+      if (sourceModelReg) {
+        const targetModelReg = sourceModelReg.get(modelName);
+        if (targetModelReg) {
+          targetModelReg.set(relationshipId, record);
+        }
+      }
+
+      // Wire inverse hasMany if it exists
+      const inverseHasMany = hasManyReg.get(modelName)?.get(sourceModelName)?.get(record.id);
+
+      if (inverseHasMany && !inverseHasMany.includes(sourceRecord)) {
+        inverseHasMany.push(sourceRecord);
+      }
+    }
+
+    // Clear the pending queue
+    pendingBelongsTo.length = 0;
+  }
+
+  return record;
+}
+
+export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: CreateRecordOptions = {}): void {
+  if (!rawData) throw new Error('rawData must be passed in to updateRecord call');
+
+  // Guard: read-only views cannot be updated
+  const modelName = record?.__model?.__name;
+  if (modelName && Orm.instance?.isView?.(modelName)) {
+    throw new Error(`Cannot update records for read-only view '${modelName}'`);
+  }
+
+  const options = { ...defaultOptions, ...userOptions, update: true };
+
+  record.serialize(rawData, options);
+}
+
+/**
+ * gets the next available id based on last record entry.
+ *
+ * In MySQL mode with numeric IDs, assigns a temporary pending ID.
+ * MySQL's AUTO_INCREMENT provides the real ID after INSERT.
+ */
+function assignRecordId(modelName: string, rawData: { [key: string]: unknown }): void {
+  if (rawData.id) return;
+
+  // In SQL mode with numeric IDs, defer to database auto-increment
+  if (Orm.instance?.sqlDb && !isStringIdModel(modelName)) {
+    rawData.id = `__pending_${Date.now()}_${Math.random()}`;
+    rawData.__pendingSqlId = true;
+    return;
+  }
+
+  const storeMap = store.get(modelName);
+  if (!storeMap) throw new Error(`Cannot assign record ID: model "${modelName}" not found in store`);
+  const modelStore = Array.from(storeMap.values()).filter(isOrmRecord);
+  const lastRecord = modelStore.at(-1);
+  rawData.id = lastRecord ? (lastRecord.id as number) + 1 : 1;
+}
+
+function isStringIdModel(modelName: string): boolean {
+  const modelClass = Orm.instance.getRecordClasses(modelName).modelClass as (new (name: string) => { [key: string]: unknown }) | undefined;
+  if (!modelClass) return false;
+
+  const model = new modelClass(modelName);
+
+  return (model.id as { type?: string } | undefined)?.type === 'string';
+}