js-bao 0.12.0-alpha.3 → 0.12.0-alpha.4

package/README.md

@@ -1023,6 +1023,12 @@ const electronicsCount = await Product.count({
 
 Perform complex data analysis with grouping, statistical operations, and faceting.
 
+`aggregate` answers one row per group: the `groupBy` values under `group`, as
+stored (`null` for a missing field), and each operation's value beside it under
+`count` or `<type>_<field>` — even when it is the only operation. Rows come back
+in `sort` order; no matching records gives `[]`. Two `groupBy` entries that
+would share a key in `group` throw `Ambiguous aggregation group keys`.
+
 ### Basic Aggregation
 
 ```typescript
@@ -1031,7 +1037,11 @@ const categoryCounts = await Product.aggregate({
   groupBy: ["category"],
   operations: [{ type: "count" }],
 });
-// Result: { "Electronics": 25, "Books": 18, "Clothing": 12 }
+// Result: [
+//   { group: { category: "Electronics" }, count: 25 },
+//   { group: { category: "Books" }, count: 18 },
+//   { group: { category: "Clothing" }, count: 12 }
+// ]
 
 // Multiple statistical operations
 const categoryStats = await Product.aggregate({
@@ -1044,8 +1054,9 @@ const categoryStats = await Product.aggregate({
     { type: "max", field: "price" },
   ],
 });
-// Result: {
-//   "Electronics": {
+// Result: [
+//   {
+//     group: { category: "Electronics" },
 //     count: 25,
 //     avg_price: 299.99,
 //     sum_price: 7499.75,
@@ -1053,7 +1064,7 @@ const categoryStats = await Product.aggregate({
 //     max_price: 1299.99
 //   },
 //   ...
-// }
+// ]
 ```
 
 ### Multi-Dimensional Grouping
@@ -1064,15 +1075,11 @@ const salesData = await Product.aggregate({
   groupBy: ["category", "brand"],
   operations: [{ type: "count" }, { type: "sum", field: "revenue" }],
 });
-// Result: {
-//   "Electronics": {
-//     "Apple": { count: 12, sum_revenue: 15000 },
-//     "Samsung": { count: 8, sum_revenue: 9500 }
-//   },
-//   "Books": {
-//     "Penguin": { count: 25, sum_revenue: 450 }
-//   }
-// }
+// Result: [
+//   { group: { category: "Electronics", brand: "Apple" }, count: 12, sum_revenue: 15000 },
+//   { group: { category: "Electronics", brand: "Samsung" }, count: 8, sum_revenue: 9500 },
+//   { group: { category: "Books", brand: "Penguin" }, count: 25, sum_revenue: 450 }
+// ]
 ```
 
 ### StringSet Aggregation
@@ -1105,14 +1112,21 @@ const tagCounts = await Article.aggregate({
   groupBy: ["tags"], // StringSet faceting
   operations: [{ type: "count" }],
 });
-// Result: { "javascript": 45, "react": 32, "tutorial": 28 }
+// Result: [
+//   { group: { tags: "javascript" }, count: 45 },
+//   { group: { tags: "react" }, count: 32 },
+//   { group: { tags: "tutorial" }, count: 28 }
+// ]
 
 // Membership-based grouping (articles that have specific tag vs don't)
 const urgentCounts = await Article.aggregate({
   groupBy: [{ field: "tags", contains: "urgent" }],
   operations: [{ type: "count" }],
 });
-// Result: { "true": 5, "false": 120 }
+// Result: [
+//   { group: { has_tags_urgent: "true" }, count: 5 },
+//   { group: { has_tags_urgent: "false" }, count: 120 }
+// ]
 
 // Complex aggregation with filtering and sorting
 const topTags = await Article.aggregate({
@@ -1254,7 +1268,10 @@ const tagStats = await Article.aggregate({
   groupBy: [{ field: "tags", contains: "tutorial" }],
   operations: [{ type: "count" }],
 });
-// Result: { "true": 25, "false": 75 }
+// Result: [
+//   { group: { has_tags_tutorial: "true" }, count: 25 },
+//   { group: { has_tags_tutorial: "false" }, count: 75 }
+// ]
 ```
 
 ## Database Engine Specifics
@@ -1556,9 +1573,30 @@ See the `examples/` directory for complete working examples:
 
 ## Release notes
 
-Changes to the on-disk behaviour of `js-bao/cloudflare/do` (`DurableObjectEngine`)
-that a store's owner can observe. Newest first.
-
+Changes a consumer of this package can observe, including the on-disk
+behaviour of `js-bao/cloudflare/do` (`DurableObjectEngine`). Newest first.
+
+- **Breaking: `createModelClass` is removed** (#4285). It is no longer exported
+  from `js-bao` (or re-exported from `js-bao-wss-client`). Define a model as
+  `class X extends BaseModel {}` and attach its schema with
+  `attachAndRegisterModel(X, schema)`, as [Defining Models](#defining-models-schema-first-no-decorators)
+  shows; instance methods, getters and statics go on the class body. The v1
+  codegen (`js-bao-codegen`) no longer recognises a `createModelClass(...)`
+  call as a model definition; it reads the class-based pattern as before.
+- **New stores get a keyed StringSet table** (#3881). A store the engine
+  creates declares `stringset_index` as `PRIMARY KEY (_type, _record_id, field,
+  value) WITHOUT ROWID` with `idx_ss_type_field_value` as its one named index,
+  so a StringSet value costs two rows written instead of three.
+  `DURABLE_OBJECT_SCHEMA_OPTIONS.memberShape` is `"keyed"`, and
+  `engine.memberTableShape` answers `"keyed"` for such a store. An existing
+  store keeps its record-first or field-first table; all three shapes return
+  the same results. On the platform, a plain document converts at its next
+  projection rebuild; databases and large documents keep their shape.
+  `rebuildMemberTable` now builds the keyed table. Rollback floor: a keyed table
+  has no `rowid`, so once a keyed store exists do not roll back past the
+  release that first returned StringSet values sorted by code point (it reads
+  `ORDER BY value`); an older release fails on a keyed table with `no such
+  column: rowid`.
 - **New stores get a record-first StringSet table** (#3877). A store the
   engine creates declares `stringset_index` with `UNIQUE(_type, _record_id,
   field, value)` (record-first) instead of `UNIQUE(_type, field, _record_id,

package/dist/browser.cjs

@@ -8672,6 +8672,51 @@ var init_format2ClientWrite = __esm({
   }
 });
 
+// src/utils/aggregationRows.ts
+function aggregationGroupKey(level) {
+  return typeof level === "string" ? level : `has_${level.field}_${level.contains}`;
+}
+function aggregationOperationKey(operation) {
+  return operation.type === "count" ? "count" : `${operation.type}_${operation.field}`;
+}
+function positionalGroupAlias(index) {
+  return `_g${index}`;
+}
+function ambiguousAggregationGroupKeysMessage(key) {
+  return `Ambiguous aggregation group keys: '${key}' names more than one groupBy level`;
+}
+function findAmbiguousAggregationGroupKey(groupBy) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const level of groupBy) {
+    const key = aggregationGroupKey(level);
+    if (seen.has(key)) return key;
+    seen.add(key);
+  }
+  return null;
+}
+function aggregationRow(sqlRow, groupBy, operations, readLevel) {
+  const group = {};
+  groupBy.forEach((level, index) => {
+    Object.defineProperty(group, aggregationGroupKey(level), {
+      value: readLevel(level, index),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  });
+  const row = { group };
+  for (const operation of operations) {
+    const key = aggregationOperationKey(operation);
+    row[key] = sqlRow[key] ?? null;
+  }
+  return row;
+}
+var init_aggregationRows = __esm({
+  "src/utils/aggregationRows.ts"() {
+    "use strict";
+  }
+});
+
 // src/models/relationshipManager.ts
 function warnIfOrderFieldNullable(modelClass, orderByField, relationshipDescription) {
   if (ALWAYS_PRESENT_ORDER_FIELDS.has(orderByField)) return;
@@ -8957,7 +9002,7 @@ var init_ModelRegistry = __esm({
        * A registry for ONE `initJsBao` instance (#3039).
        *
        * The global singleton stays the registration target for
-       * `attachAndRegisterModel` / `createModelClass`; this is the per-instance
+       * `attachAndRegisterModel`; this is the per-instance
        * view the ORM actually resolves schemas through, so two clients that
        * register different models under the same name no longer overwrite each
        * other's include translation and relationship validation.
@@ -9005,7 +9050,7 @@ var init_ModelRegistry = __esm({
         const modelName = modelClass?.modelName ?? schema?.options?.name;
         if (!modelName || !schema?.options?.name || !schema?.resolvedUniqueConstraints) {
           throw new Error(
-            `[initJsBao] Cannot register a model class with no name. Build it with defineModelSchema and attachAndRegisterModel (or createModelClass) so it carries a static modelName and a schema with resolvedUniqueConstraints.`
+            `[initJsBao] Cannot register a model class with no name. Build it with defineModelSchema and attachAndRegisterModel so it carries a static modelName and a schema with resolvedUniqueConstraints.`
           );
         }
         const existing = this.models.get(modelName);
@@ -9054,7 +9099,7 @@ var init_ModelRegistry = __esm({
       registerModel(modelClass, options, fields) {
         if (!options.name) {
           throw new Error(
-            `[ModelRegistry] Model class is missing a name in its options. Ensure the schema passed to defineModelSchema/createModelClass/attachAndRegisterModel includes a 'name' property.`
+            `[ModelRegistry] Model class is missing a name in its options. Ensure the schema passed to defineModelSchema/attachAndRegisterModel includes a 'name' property.`
           );
         }
         if (this.models.has(options.name)) {
@@ -9098,7 +9143,7 @@ var init_ModelRegistry = __esm({
         }
         return infos;
       }
-      // Helper to get model name from class (set by attachAndRegisterModel/createModelClass)
+      // Helper to get model name from class (set by attachAndRegisterModel)
       getModelNameFromClass(modelClass) {
         return modelClass.modelName;
       }
@@ -9109,13 +9154,13 @@ var init_ModelRegistry = __esm({
             const modelName = this.getModelNameFromClass(modelClass);
             if (!modelName) {
               console.warn(
-                `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure attachAndRegisterModel (or createModelClass) was called for this model.`
+                `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure attachAndRegisterModel was called for this model.`
               );
               return;
             }
             if (!this.models.has(modelName) || this.models.get(modelName) !== modelClass) {
               console.warn(
-                `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global registry or does not match. It will be ignored. Ensure the model file is imported and attachAndRegisterModel (or createModelClass) has run.`
+                `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global registry or does not match. It will be ignored. Ensure the model file is imported and attachAndRegisterModel has run.`
               );
               return;
             }
@@ -9917,6 +9962,7 @@ var init_BaseModel = __esm({
     init_format2OfflineWindow();
     init_logger();
     init_queryTableKey();
+    init_aggregationRows();
     FORMAT2_ROW_PAGE = 500;
     UniqueConstraintViolationError = class _UniqueConstraintViolationError extends Error {
       modelName;
@@ -13209,7 +13255,7 @@ var init_BaseModel = __esm({
       /**
        * Main aggregation API - performs grouping, faceting, and statistical operations
        * @param options Aggregation configuration with groupBy, operations, filter, limit, and sort
-       * @returns Nested object structure with aggregation results
+       * @returns One row per group, `{ group, ...operationValues }`, in SQL order
        *
        * @example
        * // Simple facet count
@@ -13217,7 +13263,7 @@ var init_BaseModel = __esm({
        *   groupBy: ['tags'],
        *   operations: [{ type: 'count' }]
        * });
-       * // Result: { red: 15, blue: 8, green: 12 }
+       * // Result: [{ group: { tags: 'red' }, count: 15 }, { group: { tags: 'blue' }, count: 8 }]
        *
        * @example
        * // Multi-dimensional grouping with multiple operations
@@ -13229,9 +13275,10 @@ var init_BaseModel = __esm({
        *     { type: 'avg', field: 'score' }
        *   ],
        *   filter: { active: true },
-       *   sort: { field: 'count', direction: 'desc' },
+       *   sort: { field: 'count', direction: -1 },
        *   limit: 10
        * });
+       * // Result: [{ group: { category: 'work', status: 'open' }, count: 4, sum_amount: 120, avg_score: 3.5 }, ...]
        *
        * @example
        * // StringSet membership grouping
@@ -13239,7 +13286,7 @@ var init_BaseModel = __esm({
        *   groupBy: [{ field: 'tags', contains: 'urgent' }],
        *   operations: [{ type: 'count' }]
        * });
-       * // Result: { true: 5, false: 23 }
+       * // Result: [{ group: { has_tags_urgent: 'true' }, count: 5 }, { group: { has_tags_urgent: 'false' }, count: 23 }]
        */
       static async aggregate(options) {
         const ormContext = resolveOrmContext(this);
@@ -13289,6 +13336,10 @@ var init_BaseModel = __esm({
             }
           }
         }
+        const ambiguousKey = findAmbiguousAggregationGroupKey(options.groupBy);
+        if (ambiguousKey !== null) {
+          throw new Error(ambiguousAggregationGroupKeysMessage(ambiguousKey));
+        }
         const aggregateScope = this.documentsInScope(options.documents);
         const connected = new Set(
           this.documentsInScope()
@@ -13322,7 +13373,8 @@ var init_BaseModel = __esm({
         const processedResult = this.processAggregationResults(
           results,
           options,
-          aggregationQuery.aliasMetadata
+          aggregationQuery.aliasMetadata,
+          aggregationQuery.regularGroupBy
         );
         if (aggregationQuery.aliasMetadata && aggregationQuery.aliasMetadata.length > 0) {
           const debugMap = {};
@@ -13485,9 +13537,13 @@ var init_BaseModel = __esm({
         const selectParts = [];
         const aliasMetadata = [];
         const usedAliases = /* @__PURE__ */ new Set();
-        for (const field of regularGroupBy) {
-          selectParts.push(`${quotedMainTable}.${quoteIdentifier(field)}`);
-        }
+        regularGroupBy.forEach((field, index) => {
+          selectParts.push(
+            `${quotedMainTable}.${quoteIdentifier(field)} AS ${quoteIdentifier(
+              positionalGroupAlias(index)
+            )}`
+          );
+        });
         for (const membership of stringSetMemberships) {
           const membershipKey = this.buildMembershipKey(
             membership.field,
@@ -13597,7 +13653,9 @@ var init_BaseModel = __esm({
         }
         aliasMetadata.forEach((detail) => {
           const quotedAlias = quoteIdentifier(detail.alias);
-          groupByParts.push(`${quotedAlias}.${quotedRecordIdColumn}`);
+          groupByParts.push(
+            `CASE WHEN ${quotedAlias}.${quotedRecordIdColumn} IS NOT NULL THEN 'true' ELSE 'false' END`
+          );
         });
         if (groupByParts.length > 0) {
           sql += ` GROUP BY ${groupByParts.join(", ")}`;
@@ -13613,7 +13671,9 @@ var init_BaseModel = __esm({
             );
             if (membershipDetail) {
               sortExpression = quoteIdentifier(membershipDetail.alias);
-            } else if (requestedField.startsWith("sum_") || requestedField.startsWith("avg_") || requestedField.startsWith("min_") || requestedField.startsWith("max_")) {
+            } else if (options.operations.some(
+              (operation) => aggregationOperationKey(operation) === requestedField
+            )) {
               sortExpression = quoteIdentifier(requestedField);
             } else {
               sortExpression = `${quotedMainTable}.${quoteIdentifier(
@@ -13627,99 +13687,50 @@ var init_BaseModel = __esm({
         if (options.limit) {
           sql += ` LIMIT ${options.limit}`;
         }
-        return { sql, params, aliasMetadata };
-      }
-      /**
-       * Read one row's operation values, collapsing a single-operation aggregate
-       * to the bare value of that operation.
-       *
-       * This is the platform's one aggregate leaf rule, shared with the DO engine's
-       * `_extractOpValue` (`engines/cloudflare/createDocumentDO.ts`, behind
-       * database aggregates, registered `aggregate` operations, workflow pipeline
-       * steps and `connectDoDb` bindings) and its mirror `aggregateRowsToResult`
-       * in the platform's `src/document-projection.ts` (the document HTTP
-       * aggregate). These model statics used to collapse a lone `count` only and
-       * keep `<type>_<field>` for a lone `sum`/`avg`/`min`/`max`, so the same
-       * declared aggregation answered differently depending on the path taken;
-       * they were the outlier and moved to the shared rule in #3076 (js-bao 0.10.0).
-       *
-       * Both result-shaping branches below call this, so the StringSet-facet path
-       * and the general path cannot drift apart again. Pinned by
-       * `cli/tests/unit/aggregate-shaper-divergence-3076.test.ts` and, end to end
-       * against the HTTP aggregate, by
-       * `tests/api/http/aggregate-shape-convergence-3076.test.ts`.
-       */
-      static extractAggregationLeaf(row, operations) {
-        const valueFor = (operation) => operation.type === "count" ? row.count : row[`${operation.type}_${operation.field}`];
-        if (operations.length === 1) return valueFor(operations[0]);
-        const leaf = {};
-        for (const operation of operations) {
-          if (operation.type === "count") leaf.count = row.count;
-          else leaf[`${operation.type}_${operation.field}`] = valueFor(operation);
-        }
-        return leaf;
+        return { sql, params, aliasMetadata, regularGroupBy };
       }
       /**
-       * Process aggregation results into nested structure.
+       * Shape SQL rows into aggregation rows: `{ group, ...operationValues }`, in
+       * the order SQL returned them.
        *
-       * The leaf under the last group value follows the one platform rule — see
-       * {@link BaseModel.extractAggregationLeaf}.
+       * A facet plan's rows carry the member value as `group_key`; a regular
+       * plan's carry each plain level under its positional alias (`_g<i>`, `i`
+       * its index in `regularGroupBy`, the plan's selected plain fields) and each
+       * membership under the alias `aliasMetadata` records for it. A level the
+       * plan did not select (a StringSet facet beside other levels) is `null`.
+       * Without `regularGroupBy`, every string level counts as a plain one. Shared with the DO engine's
+       * `_processAggregationResults` (`engines/cloudflare/createDocumentDO.ts`) and
+       * the platform's document HTTP aggregate (`aggregateRowsToResult`); the three
+       * are pinned against each other by
+       * `cli/tests/unit/aggregate-shaper-divergence-3076.test.ts`.
        */
-      static processAggregationResults(results, options, aliasMetadata) {
-        if (results.length === 0) {
-          return {};
-        }
+      static processAggregationResults(results, options, aliasMetadata, regularGroupBy) {
         const membershipAliasLookup = /* @__PURE__ */ new Map();
         if (aliasMetadata) {
           for (const detail of aliasMetadata) {
             membershipAliasLookup.set(detail.membershipKey, detail.alias);
-            membershipAliasLookup.set(detail.originalAlias, detail.alias);
           }
         }
-        if (options.groupBy.length === 1 && typeof options.groupBy[0] === "string" && results[0].hasOwnProperty("group_key")) {
-          const facetResult = {};
-          for (const row of results) {
-            facetResult[row.group_key] = this.extractAggregationLeaf(
-              row,
-              options.operations
+        const facet = options.groupBy.length === 1 && typeof options.groupBy[0] === "string" && results.length > 0 && Object.prototype.hasOwnProperty.call(results[0], "group_key");
+        return results.map((row) => {
+          let plainIndex = 0;
+          return aggregationRow(row, options.groupBy, options.operations, (level) => {
+            if (facet) return row.group_key ?? null;
+            if (typeof level === "string") {
+              const index = regularGroupBy ? regularGroupBy.indexOf(level) : plainIndex++;
+              return index < 0 ? null : row[positionalGroupAlias(index)] ?? null;
+            }
+            const resolvedAlias = membershipAliasLookup.get(
+              this.buildMembershipKey(level.field, level.contains)
             );
-          }
-          return facetResult;
-        }
-        const nestedResult = {};
-        for (const row of results) {
-          let current = nestedResult;
-          for (let i = 0; i < options.groupBy.length; i++) {
-            const groupBy = options.groupBy[i];
-            let key;
-            if (typeof groupBy === "string") {
-              key = String(row[groupBy]);
-            } else {
-              const membershipKey = this.buildMembershipKey(
-                groupBy.field,
-                groupBy.contains
-              );
-              const resolvedAlias = membershipAliasLookup.get(membershipKey) || membershipAliasLookup.get(
-                `has_${groupBy.field}_${groupBy.contains}`
+            if (!resolvedAlias) {
+              throw new Error(
+                `Missing alias metadata for StringSet membership ${level.field}:${level.contains}`
               );
-              if (!resolvedAlias) {
-                throw new Error(
-                  `Missing alias metadata for StringSet membership ${groupBy.field}:${groupBy.contains}`
-                );
-              }
-              key = row[resolvedAlias];
             }
-            if (i === options.groupBy.length - 1) {
-              current[key] = this.extractAggregationLeaf(row, options.operations);
-            } else {
-              if (!current[key]) {
-                current[key] = {};
-              }
-              current = current[key];
-            }
-          }
-        }
-        return nestedResult;
+            return row[resolvedAlias] ?? null;
+          });
+        });
       }
       /**
        * Document-style query API - returns single result or null
@@ -14568,7 +14579,6 @@ __export(browser_exports, {
   compareRecordIds: () => compareRecordIds,
   completeOverlayEntries: () => completeOverlayEntries,
   configuredOfflineWindowDays: () => configuredOfflineWindowDays,
-  createModelClass: () => createModelClass,
   decideDeferredReplay: () => decideDeferredReplay,
   decodeFoldedState: () => decodeFoldedState,
   decodeFormat2StoreError: () => decodeFormat2StoreError,
@@ -20422,7 +20432,7 @@ var DocumentManagerImpl = class {
     const boundTo = modelClass?._ormContext;
     if (boundTo && boundTo !== this.ormContext && !boundTo.destroyed) {
       throw new Error(
-        `[initJsBao] Model '${modelName}' is bound to live js-bao instance #${boundTo.instanceId}. Give instance #${this.ormContext.instanceId} its own model class (a fresh createModelClass / attachAndRegisterModel result).`
+        `[initJsBao] Model '${modelName}' is bound to live js-bao instance #${boundTo.instanceId}. Give instance #${this.ormContext.instanceId} its own model class (a fresh class from defineModelSchema + attachAndRegisterModel).`
       );
     }
     const { added } = this.modelRegistry.adoptModel(modelClass, {
@@ -20575,7 +20585,7 @@ function bindModelClass(ctx, modelName, modelClass, onLiveConflict) {
   }
   if (onLiveConflict === "throw") {
     throw new Error(
-      `[initJsBao] Model '${modelName}' is bound to live js-bao instance #${current.instanceId}. Give instance #${ctx.instanceId} its own model class (a fresh createModelClass / attachAndRegisterModel result).`
+      `[initJsBao] Model '${modelName}' is bound to live js-bao instance #${current.instanceId}. Give instance #${ctx.instanceId} its own model class (a fresh class from defineModelSchema + attachAndRegisterModel).`
     );
   }
   console.warn(
@@ -20812,36 +20822,6 @@ function buildDefinedModelSchema(input) {
   };
   return schema;
 }
-function createModelClass(config) {
-  const { schema, baseClass = BaseModel2, methods, statics } = config;
-  const ParentClass = baseClass;
-  class GeneratedModel extends ParentClass {
-  }
-  Object.defineProperty(GeneratedModel, "name", {
-    value: schema.options.name,
-    configurable: true
-  });
-  const methodDefinitions = methods?.();
-  if (methodDefinitions) {
-    const descriptors = Object.getOwnPropertyDescriptors(methodDefinitions);
-    for (const [key, descriptor] of Object.entries(descriptors)) {
-      if (key === "constructor") continue;
-      Object.defineProperty(GeneratedModel.prototype, key, descriptor);
-    }
-  }
-  if (statics) {
-    const staticDefinitions = statics(
-      GeneratedModel
-    );
-    const descriptors = Object.getOwnPropertyDescriptors(staticDefinitions);
-    for (const [key, descriptor] of Object.entries(descriptors)) {
-      if (key === "prototype") continue;
-      Object.defineProperty(GeneratedModel, key, descriptor);
-    }
-  }
-  attachAndRegisterModel(GeneratedModel, schema);
-  return GeneratedModel;
-}
 function attachSchemaToClass(modelClass, schema) {
   modelClass.schema = schema;
   modelClass.modelName = schema.options.name;