@travetto/model-query 6.0.0-rc.1 → 6.0.0

package/README.md

@@ -46,7 +46,7 @@ export interface ModelQuerySupport {
 ```
 
 ### Crud
-Reinforcing the complexity provided in these contracts, the [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/crud.ts#L11) contract allows for bulk update/deletion by query.  This requires the underlying implementation to support these operations.
+Reinforcing the complexity provided in these contracts, the [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/crud.ts#L11) contract allows for bulk update/deletion by query.  This requires the underlying implementation to support these operations.
 
 **Code: Query Crud**
 ```typescript
@@ -86,7 +86,7 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
    * @param field The field to facet on
    * @param query Additional query filtering
    */
-  facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<{ key: string, count: number }[]>;
+  facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]>;
 }
 ```
 
@@ -173,12 +173,13 @@ One of the complexities of abstracting multiple storage mechanisms, is providing
    *  `{ $and: [] }` provides a grouping in which all sub clauses are require,
    *  `{ $or: [] }` provides a grouping in which at least one of the sub clauses is require,
    *  `{ $not: { } }` negates a clause
+
 A sample query for `User`'s might be:
 
 **Code: Using the query structure for specific queries**
 ```typescript
 import { ModelQuerySupport } from '@travetto/model-query';
-import { User } from './user';
+import { User } from './user.ts';
 
 export class UserSearch {
   service: ModelQuerySupport;
@@ -214,19 +215,17 @@ In addition to the provided contracts, the module also provides common utilities
 **Code: MongoDB Service Test Configuration**
 ```typescript
 import { Suite } from '@travetto/test';
-
-import { ModelQuerySuite } from '@travetto/model-query/support/test/query';
-import { ModelQueryCrudSuite } from '@travetto/model-query/support/test/crud';
-import { ModelQueryFacetSuite } from '@travetto/model-query/support/test/facet';
-import { ModelQueryPolymorphismSuite } from '@travetto/model-query/support/test/polymorphism';
-import { ModelQuerySuggestSuite } from '@travetto/model-query/support/test/suggest';
-import { ModelQueryCrudSupport } from '@travetto/model-query/src/service/crud';
-import { ModelQuerySuggestSupport } from '@travetto/model-query/src/service/suggest';
-import { ModelQueryFacetSupport } from '@travetto/model-query/src/service/facet';
 import { Config } from '@travetto/config';
 import { Injectable } from '@travetto/di';
+import { ModelQueryFacetSupport, ModelQuerySuggestSupport, ModelQueryCrudSupport } from '@travetto/model-query';
+
+import { ModelQuerySuite } from '@travetto/model-query/support/test/query.ts';
+import { ModelQueryCrudSuite } from '@travetto/model-query/support/test/crud.ts';
+import { ModelQueryFacetSuite } from '@travetto/model-query/support/test/facet.ts';
+import { ModelQueryPolymorphismSuite } from '@travetto/model-query/support/test/polymorphism.ts';
+import { ModelQuerySuggestSuite } from '@travetto/model-query/support/test/suggest.ts';
 
-import { QueryModelService } from './query-service';
+import { QueryModelService } from './query-service.ts';
 
 @Config('model.custom')
 class CustomModelConfig { }

package/__index__.ts

@@ -1,7 +1,13 @@
-export * from './src/model/query';
-export * from './src/model/where-clause';
-export * from './src/service/crud';
-export * from './src/service/query';
-export * from './src/service/facet';
-export * from './src/service/suggest';
-export * from './src/verifier';
+export * from './src/model/query.ts';
+export * from './src/model/where-clause.ts';
+export * from './src/types/crud.ts';
+export * from './src/types/query.ts';
+export * from './src/types/facet.ts';
+export * from './src/types/suggest.ts';
+
+export * from './src/util/query.ts';
+export * from './src/util/suggest.ts';
+export * from './src/util/facet.ts';
+export * from './src/util/crud.ts';
+
+export * from './src/verifier.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-query",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0",
   "description": "Datastore abstraction for advanced query support.",
   "keywords": [
     "datastore",
@@ -26,12 +26,12 @@
     "directory": "module/model-query"
   },
   "dependencies": {
-    "@travetto/di": "^6.0.0-rc.1",
-    "@travetto/model": "^6.0.0-rc.1",
-    "@travetto/schema": "^6.0.0-rc.1"
+    "@travetto/di": "^6.0.0",
+    "@travetto/model": "^6.0.0",
+    "@travetto/schema": "^6.0.0"
   },
   "peerDependencies": {
-    "@travetto/test": "^6.0.0-rc.1"
+    "@travetto/test": "^6.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/test": {

package/src/internal/{util/types.ts → types.ts}

@@ -1,7 +1,5 @@
-import { FieldConfig } from '@travetto/schema';
-import { Class } from '@travetto/runtime';
-
-import { PointImpl } from '../model/point';
+import { FieldConfig, Point } from '@travetto/schema';
+import { Class, toConcrete } from '@travetto/runtime';
 
 const st = (t: string | string[], isArr: boolean = false): Set<string> =>
   new Set((Array.isArray(t) ? t : [t]).map(v => isArr ? `${v}[]` : v));
@@ -18,6 +16,8 @@ const geo = (type: string): Record<string, Set<string>> => ({
   $geoIntersects: st(type, true)
 });
 
+const PointImpl = toConcrete<Point>();
+
 /**
  * Basic type support
  */
@@ -64,11 +64,11 @@ export class TypeUtil {
     } else if (v instanceof Date) {
       return 'Date';
     } else if (Array.isArray(v)) {
-      const ret: string = `${this.getActualType(v[0])}[]`;
-      if (v.length === 2 && ret === 'number[]') {
+      const typeString: string = `${this.getActualType(v[0])}[]`;
+      if (v.length === 2 && typeString === 'number[]') {
         return 'Point';
       } else {
-        return ret;
+        return typeString;
       }
     }
     throw new Error(`Unknown type for ${v}`);

package/src/model/query.ts

@@ -1,4 +1,4 @@
-import { WhereClauseRaw, RetainFields } from './where-clause';
+import { WhereClauseRaw, RetainFields } from './where-clause.ts';
 
 type SelectClauseRaw<T> = {
   [P in keyof T]?:

package/src/model/where-clause.ts

@@ -1,11 +1,5 @@
 import type { Primitive, TimeSpan } from '@travetto/runtime';
-
-/**
- * Point as [number,number] with validation and binding support
- *
- * @concrete ../internal/model/point#PointImpl
- */
-export type Point = [number, number];
+import { Point } from '@travetto/schema';
 
 export type QueryPrimitive = Primitive | Point;
 export type QueryPrimitiveArray = QueryPrimitive[];

package/src/{service → types}/crud.ts

@@ -1,12 +1,12 @@
 import { Class } from '@travetto/runtime';
 import { ModelCrudSupport, ModelType } from '@travetto/model';
 
-import { ModelQuerySupport } from './query';
-import { ModelQuery } from '../model/query';
+import { ModelQuerySupport } from './query.ts';
+import { ModelQuery } from '../model/query.ts';
 
 /**
  * The contract for a model service with query support
- * @concrete ../internal/service/common#ModelQueryCrudSupportTarget
+ * @concrete
  */
 export interface ModelQueryCrudSupport extends ModelCrudSupport, ModelQuerySupport {
   /**

package/src/{service → types}/facet.ts

@@ -1,13 +1,15 @@
 import { Class } from '@travetto/runtime';
 import { ModelType } from '@travetto/model';
 
-import { ModelQuery } from '../model/query';
-import { ModelQuerySupport } from './query';
-import { ValidStringFields } from '../model/where-clause';
+import { ModelQuery } from '../model/query.ts';
+import { ModelQuerySupport } from './query.ts';
+import { ValidStringFields } from '../model/where-clause.ts';
+
+export type ModelQueryFacet = { key: string, count: number };
 
 /**
  * The contract for a model service with faceting support
- * @concrete ../internal/service/common#ModelQueryFacetSupportTarget
+ * @concrete
  */
 export interface ModelQueryFacetSupport extends ModelQuerySupport {
   /**
@@ -16,5 +18,5 @@ export interface ModelQueryFacetSupport extends ModelQuerySupport {
    * @param field The field to facet on
    * @param query Additional query filtering
    */
-  facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<{ key: string, count: number }[]>;
+  facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]>;
 }

package/src/{service → types}/query.ts

@@ -1,11 +1,11 @@
 import { Class } from '@travetto/runtime';
 import { ModelType } from '@travetto/model';
 
-import { ModelQuery, PageableModelQuery } from '../model/query';
+import { ModelQuery, PageableModelQuery } from '../model/query.ts';
 
 /**
  * The contract for a model service with query support
- * @concrete ../internal/service/common#ModelQuerySupportTarget
+ * @concrete
  */
 export interface ModelQuerySupport {
   /**

package/src/{service → types}/suggest.ts

@@ -1,13 +1,13 @@
 import { Class } from '@travetto/runtime';
 import { ModelType } from '@travetto/model';
 
-import { PageableModelQuery } from '../model/query';
-import { ModelQuerySupport } from './query';
-import { ValidStringFields } from '../model/where-clause';
+import { PageableModelQuery } from '../model/query.ts';
+import { ModelQuerySupport } from './query.ts';
+import { ValidStringFields } from '../model/where-clause.ts';
 
 /**
  * The contract for a model service with suggesting support
- * @concrete ../internal/service/common#ModelQuerySuggestSupportTarget
+ * @concrete
  */
 export interface ModelQuerySuggestSupport extends ModelQuerySupport {
   /**

package/src/{internal/service/expiry.ts → util/crud.ts}

@@ -1,14 +1,14 @@
-import { Class } from '@travetto/runtime';
-import { ModelCrudSupport } from '@travetto/model';
-import { ModelRegistry } from '@travetto/model/src/registry/model';
-import { ModelType } from '@travetto/model/src/types/model';
+import { Class, hasFunction } from '@travetto/runtime';
+import { ModelType, ModelCrudSupport, ModelRegistry } from '@travetto/model';
 
-import { ModelQueryCrudSupport } from '../../service/crud';
+import { ModelQueryCrudSupport } from '../types/crud.ts';
+
+export class ModelQueryCrudUtil {
+  /**
+   * Type guard for determining if service supports query crud operations
+   */
+  static isSupported = hasFunction<ModelQueryCrudSupport>('deleteByQuery');
 
-/**
- * Utils for query expiry support
- */
-export class ModelQueryExpiryUtil {
   /**
    * Delete all expired
    */

package/src/util/facet.ts

@@ -0,0 +1,10 @@
+import { hasFunction } from '@travetto/runtime';
+
+import { ModelQueryFacetSupport } from '../types/facet.ts';
+
+export class ModelQueryFacetUtil {
+  /**
+   * Type guard for determining if service supports query facet operations
+   */
+  static isSupported = hasFunction<ModelQueryFacetSupport>('facet');
+}

package/src/{internal/service → util}/query.ts

@@ -1,15 +1,20 @@
-import { Class, AppError, TimeUtil, castTo } from '@travetto/runtime';
-import { ModelRegistry, NotFoundError } from '@travetto/model';
-import { ModelType } from '@travetto/model/src/types/model';
+import { Class, AppError, TimeUtil, castTo, hasFunction } from '@travetto/runtime';
+import { ModelType, ModelRegistry, NotFoundError } from '@travetto/model';
 import { SchemaRegistry } from '@travetto/schema';
 
-import { WhereClause, WhereClauseRaw } from '../../model/where-clause';
+import { WhereClause, WhereClauseRaw } from '../model/where-clause.ts';
+import { ModelQuerySupport } from '../types/query.ts';
 
 /**
  * Common model utils, that should be usable by end users
  */
 export class ModelQueryUtil {
 
+  /**
+   * Type guard for determining if service supports query operations
+   */
+  static isSupported = hasFunction<ModelQuerySupport>('query');
+
   /**
    * Resolve comparator
    * @param val
@@ -26,13 +31,13 @@ export class ModelQueryUtil {
   /**
    * Verify result set is singular, and decide if failing on many should happen
    */
-  static verifyGetSingleCounts<T extends ModelType>(cls: Class<T>, failOnMany: boolean, res?: T[], where?: WhereClause<T>): T {
-    res = res ?? [];
-    if (res.length === 1 || res.length > 1 && !failOnMany) {
-      return res[0]!;
+  static verifyGetSingleCounts<T extends ModelType>(cls: Class<T>, failOnMany: boolean, result?: T[], where?: WhereClause<T>): T {
+    result = result ?? [];
+    if (result.length === 1 || result.length > 1 && !failOnMany) {
+      return result[0]!;
     }
     const requestedId = ((where && 'id' in where && typeof where.id === 'string') ? where.id : undefined);
-    if (res.length === 0) {
+    if (result.length === 0) {
       if (requestedId) {
         throw new NotFoundError(cls, requestedId);
       } else {
@@ -41,7 +46,7 @@ export class ModelQueryUtil {
         throw err;
       }
     } else {
-      throw new AppError(`Invalid number of results: ${res.length}`, { category: 'data' });
+      throw new AppError(`Invalid number of results: ${result.length}`, { category: 'data' });
     }
   }
 

package/src/{internal/service → util}/suggest.ts

@@ -1,15 +1,21 @@
 import { ModelRegistry, ModelType } from '@travetto/model';
-import { castTo, Class } from '@travetto/runtime';
+import { castTo, Class, hasFunction } from '@travetto/runtime';
 import { SchemaRegistry } from '@travetto/schema';
 
-import { PageableModelQuery, Query } from '../../model/query';
-import { ValidStringFields, WhereClauseRaw } from '../../model/where-clause';
+import { PageableModelQuery, Query } from '../model/query.ts';
+import { ValidStringFields, WhereClauseRaw } from '../model/where-clause.ts';
+import { ModelQuerySuggestSupport } from '../types/suggest.ts';
 
 /**
  * Tools for building suggestion queries
  */
 export class ModelQuerySuggestUtil {
 
+  /**
+   * Type guard for determining if service supports query suggest operations
+   */
+  static isSupported = hasFunction<ModelQuerySuggestSupport>('suggest');
+
   /**
    * Build regex for suggesting
    */
@@ -68,7 +74,7 @@ export class ModelQuerySuggestUtil {
       }
     }
     return out
-      .sort((a, b) => a[0].localeCompare(b[0]))
+      .toSorted((a, b) => a[0].localeCompare(b[0]))
       .map((a) => a[1])
       .filter((x, i, arr) => x !== arr[i - 1])
       .slice(0, limit ?? 10);

package/src/verifier.ts

@@ -1,9 +1,10 @@
+/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none"} ] */
 import { DataUtil, SchemaRegistry, ValidationResultError, ValidationError } from '@travetto/schema';
 import { Class } from '@travetto/runtime';
 
-import { ModelQuery, Query, PageableModelQuery } from './model/query';
+import { ModelQuery, Query, PageableModelQuery } from './model/query.ts';
 
-import { TypeUtil } from './internal/util/types';
+import { TypeUtil } from './internal/types.ts';
 
 type SimpleType = keyof typeof TypeUtil.OPERATORS;
 
@@ -127,7 +128,7 @@ export class QueryVerifier {
       }
       return;
     } else {
-      const keys = Object.keys(value).sort();
+      const keys = Object.keys(value).toSorted();
 
       if (keys.length !== 1 && !(
         keys.length >= 2 &&
@@ -215,7 +216,7 @@ export class QueryVerifier {
    * Handle group by clause
    */
   static processGroupByClause(state: State, value: object): void {
-
+    // TODO: Handle group by?
   }
 
   /**

package/support/doc.support.tsx

@@ -1,22 +1,32 @@
 /** @jsxImportSource @travetto/doc */
 import { d, DocJSXElementByFn, DocJSXElement, DocFileUtil } from '@travetto/doc';
+import { Runtime, toConcrete } from '@travetto/runtime';
+
+import { ModelQueryCrudSupport } from '../src/types/crud.ts';
+import { ModelQuerySupport } from '../src/types/query.ts';
+import { ModelQueryFacetSupport, } from '../src/types/facet.ts';
+import { ModelQuerySuggestSupport } from '../src/types/suggest.ts';
+
+const toLink = (title: string, target: Function): DocJSXElementByFn<'CodeLink'> =>
+  d.codeLink(title, Runtime.getSourceFile(target), new RegExp(`\\binterface\\s+${target.name}`));
 
 export const Links = {
-  QueryCrud: d.codeLink('Query Crud', '@travetto/model-query/src/service/crud.ts', /export interface/),
-  QueryFacet: d.codeLink('Facet', '@travetto/model-query/src/service/facet.ts', /export interface/),
-  QuerySuggest: d.codeLink('Suggest', '@travetto/model-query/src/service/suggest.ts', /export interface/),
-  Query: d.codeLink('Query', '@travetto/model-query/src/service/query.ts', /export interface/),
+  QueryCrud: toLink('Query Crud', toConcrete<ModelQueryCrudSupport>()),
+  QueryFacet: toLink('Facet', toConcrete<ModelQueryFacetSupport>()),
+  QuerySuggest: toLink('Suggest', toConcrete<ModelQuerySuggestSupport>()),
+  Query: toLink('Query', toConcrete<ModelQuerySupport>()),
 };
 
 export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
   const { content } = DocFileUtil.readSource(fn);
   const found: DocJSXElementByFn<'CodeLink'>[] = [];
-  const seen = new Set();
+  const seen = new Set<string>();
   for (const [, key] of content.matchAll(/Model(Query(Suggest|Facet|Crud)?)Support/g)) {
-    if (!seen.has(key)) {
+    if (!seen.has(key) && key in Links) {
       seen.add(key);
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      found.push(Links[key as keyof typeof Links]);
+      const link = Links[key as keyof typeof Links];
+      found.push(link);
     }
   }
   return found.map(v => <li>{v}</li>);

package/support/test/crud.ts

@@ -1,12 +1,12 @@
 import assert from 'node:assert';
 
 import { Suite, Test } from '@travetto/test';
-import { BaseModelSuite } from '@travetto/model/support/test/base';
-import { ModelCrudSupport } from '@travetto/model/src/service/crud';
-import { NotFoundError } from '@travetto/model';
+import { ModelCrudSupport, NotFoundError } from '@travetto/model';
 
-import { Address, Person, Todo } from './types';
-import { ModelQueryCrudSupport } from '../../src/service/crud';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+
+import { Address, Person, Todo } from './model.ts';
+import { ModelQueryCrudSupport } from '../../src/types/crud.ts';
 
 @Suite()
 export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudSupport & ModelCrudSupport> {

package/support/test/facet.ts

@@ -1,11 +1,12 @@
 import assert from 'node:assert';
 
 import { ModelCrudSupport } from '@travetto/model';
-import { BaseModelSuite } from '@travetto/model/support/test/base';
 import { Suite, Test } from '@travetto/test';
 
-import { Person } from './types';
-import { ModelQueryFacetSupport } from '../../src/service/facet';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+
+import { Person } from './model.ts';
+import { ModelQueryFacetSupport } from '../../src/types/facet.ts';
 
 const pick = <T>(arr: T[] | readonly T[]): T => arr[Math.trunc(Math.random() * arr.length)]!;
 

package/support/test/{types.ts → model.ts}

@@ -1,8 +1,6 @@
-import { Precision, Schema, Text } from '@travetto/schema';
+import { Precision, Schema, Text, Point } from '@travetto/schema';
 import { Model, ModelType } from '@travetto/model';
 
-import { Point } from '../../src/model/where-clause';
-
 @Schema()
 export class Address {
   @Text() street1: string;

package/support/test/polymorphism.ts

@@ -1,18 +1,20 @@
 import assert from 'node:assert';
 
 import { Suite, Test } from '@travetto/test';
-import { BaseModelSuite } from '@travetto/model/support/test/base';
-import { ModelCrudSupport } from '@travetto/model/src/service/crud';
-import { Doctor, Engineer, Worker, Firefighter } from '@travetto/model/support/test/polymorphism';
-import { NotFoundError } from '@travetto/model';
+import { NotFoundError, ModelCrudSupport } from '@travetto/model';
 import { castTo } from '@travetto/runtime';
 
-import { ModelQueryCrudSupport } from '../../src/service/crud';
-import { ModelQuerySupport } from '../../src/service/query';
-import { ModelQueryFacetSupport } from '../../src/service/facet';
-import { ModelQuerySuggestSupport } from '../../src/service/suggest';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+import { Doctor, Engineer, Worker, Firefighter } from '@travetto/model/support/test/polymorphism.ts';
 
-import { isQueryCrudSupported, isQueryFacetSupported, isQuerySuggestSupported } from '../../src/internal/service/common';
+import { ModelQueryCrudSupport } from '../../src/types/crud.ts';
+import { ModelQuerySupport } from '../../src/types/query.ts';
+import { ModelQueryFacetSupport } from '../../src/types/facet.ts';
+import { ModelQuerySuggestSupport } from '../../src/types/suggest.ts';
+
+import { ModelQueryFacetUtil } from '../../src/util/facet.ts';
+import { ModelQuerySuggestUtil } from '../../src/util/suggest.ts';
+import { ModelQueryCrudUtil } from '../../src/util/crud.ts';
 
 @Suite()
 export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
@@ -42,7 +44,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     await assert.rejects(() => svc.queryOne(Firefighter, { where: { name: 'bob' } }), NotFoundError);
   }
 
-  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(isQueryCrudSupported) })
+  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQueryCrudUtil.isSupported) })
   async testCrudQuery() {
     const svc: ModelQueryCrudSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [
@@ -68,7 +70,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     assert(await this.getSize(Firefighter) === 0);
   }
 
-  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(isQuerySuggestSupported) })
+  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQuerySuggestUtil.isSupported) })
   async testSuggestQuery() {
     const svc: ModelQuerySuggestSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [
@@ -92,7 +94,7 @@ export abstract class ModelQueryPolymorphismSuite extends BaseModelSuite<ModelQu
     assert((await svc.suggestValues(Firefighter, 'name', 'r'))[0] === 'rob');
   }
 
-  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(isQueryFacetSupported) })
+  @Test({ skip: ModelQueryPolymorphismSuite.ifNot(ModelQueryFacetUtil.isSupported) })
   async testFacetQuery() {
     const svc: ModelQueryFacetSupport & ModelQuerySupport = castTo(await this.service);
     const [doc, doc2, fire, eng] = [

package/support/test/query.ts

@@ -1,14 +1,14 @@
 import assert from 'node:assert';
 
 import { Suite, Test } from '@travetto/test';
-import { BaseModelSuite } from '@travetto/model/support/test/base';
-import { ModelCrudSupport } from '@travetto/model/src/service/crud';
 import { TimeUtil } from '@travetto/runtime';
-import { NotFoundError } from '@travetto/model';
+import { NotFoundError, ModelCrudSupport } from '@travetto/model';
 
-import { Aged, Location, Names, Note, Person, SimpleList, WithNestedLists, WithNestedNestedLists } from './types';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { ModelQuerySupport } from '../../src/service/query';
+import { Aged, Location, Names, Note, Person, SimpleList, WithNestedLists, WithNestedNestedLists } from './model.ts';
+
+import { ModelQuerySupport } from '../../src/types/query.ts';
 
 @Suite()
 export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport & ModelCrudSupport> {
@@ -41,8 +41,8 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
     const none = await svc.queryCount(Person, { where: { id: { $ne: people[0].id } } });
     assert(none === 3);
 
-    const noneids = await svc.query(Person, { where: { id: { $ne: people[0].id } } });
-    assert(noneids.every(x => x.id !== people[0].id));
+    const noneIds = await svc.query(Person, { where: { id: { $ne: people[0].id } } });
+    assert(noneIds.every(x => x.id !== people[0].id));
   }
 
   @Test('verify word boundary')
@@ -255,7 +255,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
 
     assert(await svc.queryCount(Location, {}) === 25);
 
-    const ret = await svc.query(Location, {
+    const result = await svc.query(Location, {
       limit: 100,
       where: {
         point: {
@@ -264,7 +264,7 @@ export abstract class ModelQuerySuite extends BaseModelSuite<ModelQuerySupport &
       }
     });
 
-    assert(ret.length === 25);
+    assert(result.length === 25);
 
     const rad = await svc.query(Location, {
       limit: 100,

package/support/test/suggest.ts

@@ -1,11 +1,12 @@
 import assert from 'node:assert';
 
 import { ModelCrudSupport } from '@travetto/model';
-import { BaseModelSuite } from '@travetto/model/support/test/base';
 import { Suite, Test } from '@travetto/test';
 
-import { Person } from './types';
-import { ModelQuerySuggestSupport } from '../../src/service/suggest';
+import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+
+import { Person } from './model.ts';
+import { ModelQuerySuggestSupport } from '../../src/types/suggest.ts';
 
 @Suite()
 export abstract class ModelQuerySuggestSuite extends BaseModelSuite<ModelQuerySuggestSupport & ModelCrudSupport> {

package/src/internal/model/point.ts

@@ -1,16 +0,0 @@
-import { DataUtil } from '@travetto/schema';
-
-export class PointImpl {
-  static validateSchema(input: unknown): 'type' | undefined {
-    const ret = this.bindSchema(input);
-    return ret && !isNaN(ret[0]) && !isNaN(ret[1]) ? undefined : 'type';
-  }
-  static bindSchema(input: unknown): [number, number] | undefined {
-    if (Array.isArray(input) && input.length === 2) {
-      return [
-        DataUtil.coerceType(input[0], Number, false),
-        DataUtil.coerceType(input[1], Number, false)
-      ];
-    }
-  }
-}

package/src/internal/service/common.ts

@@ -1,31 +0,0 @@
-import { hasFunction } from '@travetto/runtime';
-
-import type { ModelQueryCrudSupport } from '../../service/crud';
-import type { ModelQueryFacetSupport } from '../../service/facet';
-import type { ModelQuerySupport } from '../../service/query';
-import type { ModelQuerySuggestSupport } from '../../service/suggest';
-
-export class ModelQuerySupportTarget { }
-export class ModelQueryCrudSupportTarget { }
-export class ModelQueryFacetSupportTarget { }
-export class ModelQuerySuggestSupportTarget { }
-
-/**
- * Type guard for determining if service supports query operations
- */
-export const isQuerySupported = hasFunction<ModelQuerySupport>('query');
-
-/**
- * Type guard for determining if service supports query crud operations
- */
-export const isQueryCrudSupported = hasFunction<ModelQueryCrudSupport>('deleteByQuery');
-
-/**
- * Type guard for determining if service supports query facet operations
- */
-export const isQueryFacetSupported = hasFunction<ModelQueryFacetSupport>('facet');
-
-/**
- * Type guard for determining if service supports query suggest operations
- */
-export const isQuerySuggestSupported = hasFunction<ModelQuerySuggestSupport>('suggest');