fix RepoQuery typings

app/src/data/api/DataApi.ts

@@ -1,5 +1,5 @@
 import type { DB } from "core";
-import type { EntityData, RepoQuery, RepositoryResponse } from "data";
+import type { EntityData, RepoQuery, RepoQueryIn, RepositoryResponse } from "data";
 import { type BaseModuleApiOptions, ModuleApi, type PrimaryFieldType } from "modules";
 
 export type DataApiOptions = BaseModuleApiOptions & {
@@ -19,14 +19,14 @@ export class DataApi extends ModuleApi<DataApiOptions> {
    readOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
       entity: E,
       id: PrimaryFieldType,
-      query: Partial<Omit<RepoQuery, "where" | "limit" | "offset">> = {}
+      query: Omit<RepoQueryIn, "where" | "limit" | "offset"> = {}
    ) {
       return this.get<Pick<RepositoryResponse<Data>, "meta" | "data">>([entity as any, id], query);
    }
 
    readMany<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
       entity: E,
-      query: Partial<RepoQuery> = {}
+      query: RepoQueryIn = {}
    ) {
       return this.get<Pick<RepositoryResponse<Data[]>, "meta" | "data">>(
          [entity as any],
@@ -38,7 +38,7 @@ export class DataApi extends ModuleApi<DataApiOptions> {
       E extends keyof DB | string,
       R extends keyof DB | string,
       Data = R extends keyof DB ? DB[R] : EntityData
-   >(entity: E, id: PrimaryFieldType, reference: R, query: Partial<RepoQuery> = {}) {
+   >(entity: E, id: PrimaryFieldType, reference: R, query: RepoQueryIn = {}) {
       return this.get<Pick<RepositoryResponse<Data[]>, "meta" | "data">>(
          [entity as any, id, reference],
          query ?? this.options.defaultQuery

app/src/data/entities/Entity.ts

@@ -98,8 +98,8 @@ export class Entity<
 
    getDefaultSort() {
       return {
-         by: this.config.sort_field,
-         dir: this.config.sort_dir
+         by: this.config.sort_field ?? "id",
+         dir: this.config.sort_dir ?? "asc"
       };
    }
 

app/src/data/entities/query/WhereBuilder.ts

@@ -30,7 +30,7 @@ function key(e: unknown): string {
    return e as string;
 }
 
-const expressions: TExpression<any, any, any>[] = [
+const expressions = [
    exp(
       "$eq",
       (v: Primitive) => isPrimitive(v),

app/src/data/index.ts

@@ -8,6 +8,7 @@ export * from "./prototype";
 
 export {
    type RepoQuery,
+   type RepoQueryIn,
    defaultQuerySchema,
    querySchema,
    whereSchema

app/src/data/server/data-query-impl.ts

@@ -7,7 +7,7 @@ import {
    Type,
    Value
 } from "core/utils";
-import { WhereBuilder } from "../entities";
+import { WhereBuilder, type WhereQuery } from "../entities";
 
 const NumberOrString = (options: SchemaOptions = {}) =>
    Type.Transform(Type.Union([Type.Number(), Type.String()], options))
@@ -15,10 +15,8 @@ const NumberOrString = (options: SchemaOptions = {}) =>
       .Encode(String);
 
 const limit = NumberOrString({ default: 10 });
-
 const offset = NumberOrString({ default: 0 });
 
-// @todo: allow "id" and "-id"
 const sort_default = { by: "id", dir: "asc" };
 const sort = Type.Transform(
    Type.Union(
@@ -28,20 +26,20 @@ const sort = Type.Transform(
       }
    )
 )
-   .Decode((value) => {
+   .Decode((value): { by: string; dir: "asc" | "desc" } => {
       if (typeof value === "string") {
          if (/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(value)) {
             const dir = value[0] === "-" ? "desc" : "asc";
-            return { by: dir === "desc" ? value.slice(1) : value, dir };
+            return { by: dir === "desc" ? value.slice(1) : value, dir } as any;
          } else if (/^{.*}$/.test(value)) {
-            return JSON.parse(value);
+            return JSON.parse(value) as any;
          }
 
-         return sort_default;
+         return sort_default as any;
       }
-      return value;
+      return value as any;
    })
-   .Encode(JSON.stringify);
+   .Encode((value) => value);
 
 const stringArray = Type.Transform(
    Type.Union([Type.String(), Type.Array(Type.String())], { default: [] })
@@ -65,25 +63,18 @@ export const whereSchema = Type.Transform(
    })
    .Encode(JSON.stringify);
 
-export type ShallowRepoQuery = {
-   limit?: number;
-   offset?: number;
-   sort?: string | { by: string; dir: "asc" | "desc" };
-   select?: string[];
-   with?: string[] | Record<string, ShallowRepoQuery>;
-   join?: string[];
-   where?: any;
-};
 export type RepoWithSchema = Record<
    string,
-   Omit<ShallowRepoQuery, "with"> & {
+   Omit<RepoQueryIn, "with"> & {
       with?: unknown;
    }
 >;
+
 export const withSchema = <TSelf extends TThis>(Self: TSelf) =>
    Type.Transform(Type.Union([stringArray, Type.Record(Type.String(), Self)]))
       .Decode((value) => {
-         let _value = value;
+         let _value = typeof value === "string" ? [value] : value;
+
          if (Array.isArray(value)) {
             if (!value.every((v) => typeof v === "string")) {
                throw new Error("Invalid 'with' schema");
@@ -121,6 +112,14 @@ export const querySchema = Type.Recursive(
    { $id: "query-schema" }
 );
 
-export type RepoQueryIn = Static<typeof querySchema>;
+export type RepoQueryIn = {
+   limit?: number;
+   offset?: number;
+   sort?: string | { by: string; dir: "asc" | "desc" };
+   select?: string[];
+   with?: string[] | Record<string, RepoQueryIn>;
+   join?: string[];
+   where?: WhereQuery;
+};
 export type RepoQuery = Required<StaticDecode<typeof querySchema>>;
 export const defaultQuerySchema = Value.Default(querySchema, {}) as RepoQuery;