@routier/core 0.0.5 → 0.0.7

package/dist/plugins/query/types.d.ts

@@ -34,6 +34,11 @@ export type QueryOptionValueMap<T extends {}> = {
         selector: GenericFunction<T, any>;
         fields: QueryField[];
     };
+    group: {
+        selector: GenericFunction<T, any>;
+        key: QueryField;
+        fields: QueryField[];
+    };
     filter: {
         params?: {};
         filter: ParamsFilter<T, {}> | Filter<T>;

package/dist/plugins/replication/OptimisticReplicationDbPlugin.d.ts

@@ -1,6 +1,7 @@
 import { PluginEventCallbackPartialResult, PluginEventCallbackResult } from '../../results';
 import { DbPluginBulkPersistEvent, DbPluginEvent, DbPluginQueryEvent, IDbPlugin, OptimisticReplicationPluginOptions } from '../types';
 import { BulkPersistResult } from '../../collections';
+import { ITranslatedValue } from '../translators';
 export declare class OptimisticReplicationDbPlugin implements IDbPlugin {
     protected plugins: OptimisticReplicationPluginOptions;
     protected constructor(plugins: OptimisticReplicationPluginOptions);
@@ -15,7 +16,7 @@ export declare class OptimisticReplicationDbPlugin implements IDbPlugin {
     /**
      * Will query the read plugin if there is one, otherwise the source plugin will be queried
     */
-    query<TEntity extends {}, TShape extends any = TEntity>(event: DbPluginQueryEvent<TEntity, TShape>, done: PluginEventCallbackResult<TShape>): void;
+    query<TEntity extends {}, TShape extends any = TEntity>(event: DbPluginQueryEvent<TEntity, TShape>, done: PluginEventCallbackResult<ITranslatedValue<TShape>>): void;
     destroy(event: DbPluginEvent, done: PluginEventCallbackResult<never>): void;
     bulkPersist(event: DbPluginBulkPersistEvent, done: PluginEventCallbackPartialResult<BulkPersistResult>): void;
 }

package/dist/plugins/replication/ReplicationDbPlugin.d.ts

@@ -1,6 +1,7 @@
 import { PluginEventCallbackPartialResult, PluginEventCallbackResult } from '../../results';
 import { DbPluginBulkPersistEvent, DbPluginEvent, DbPluginQueryEvent, IDbPlugin, ReplicationPluginOptions } from '../types';
 import { BulkPersistResult } from '../../collections';
+import { ITranslatedValue } from '../translators';
 export declare class ReplicationDbPlugin implements IDbPlugin {
     plugins: ReplicationPluginOptions;
     protected constructor(plugins: ReplicationPluginOptions);
@@ -15,7 +16,7 @@ export declare class ReplicationDbPlugin implements IDbPlugin {
     /**
      * Will query the read plugin if there is one, otherwise the source plugin will be queried
     */
-    query<TEntity extends {}, TShape extends any = TEntity>(event: DbPluginQueryEvent<TEntity, TShape>, done: PluginEventCallbackResult<TShape>): void;
+    query<TEntity extends {}, TShape extends any = TEntity>(event: DbPluginQueryEvent<TEntity, TShape>, done: PluginEventCallbackResult<ITranslatedValue<TShape>>): void;
     destroy(event: DbPluginEvent, done: PluginEventCallbackResult<never>): void;
     bulkPersist(event: DbPluginBulkPersistEvent, done: PluginEventCallbackPartialResult<BulkPersistResult>): void;
 }

package/dist/plugins/translators/DataTranslator.d.ts

@@ -1,5 +1,6 @@
 import { QueryOption } from "../query/types";
 import { IQuery } from "../types";
+import { ITranslatedValue } from "./types";
 export declare abstract class DataTranslator<TRoot extends {}, TShape> {
     protected query: IQuery<TRoot, TShape>;
     private functionMap;
@@ -14,5 +15,6 @@ export declare abstract class DataTranslator<TRoot extends {}, TShape> {
     abstract take(data: unknown, option: QueryOption<TShape, "take">): TShape;
     abstract sort(data: unknown, option: QueryOption<TShape, "sort">): TShape;
     abstract map(data: unknown, option: QueryOption<TShape, "map">): TShape;
-    translate(data: unknown): TShape;
+    abstract group(data: unknown, option: QueryOption<TShape, "group">): TShape;
+    translate(data: unknown): ITranslatedValue<TShape>;
 }

package/dist/plugins/translators/JsonTranslator.d.ts

@@ -3,6 +3,7 @@ import { QueryOption } from "../query/types";
 export declare class JsonTranslator<TRoot extends {}, TShape> extends DataTranslator<TRoot, TShape> {
     filter<TResult>(data: unknown, option: QueryOption<TShape, "filter">): TResult;
     map<T>(data: unknown, option: QueryOption<T, "map">): T;
+    group<T>(data: unknown, option: QueryOption<T, "group">): T;
     count<TResult extends number>(data: unknown, _: QueryOption<TShape, "count">): TResult;
     min<TResult extends string | number | Date>(data: unknown, _: QueryOption<TShape, "min">): TResult;
     max<TResult extends string | number | Date>(data: unknown, _: QueryOption<TShape, "max">): TResult;

package/dist/plugins/translators/SqlTranslator.d.ts

@@ -11,5 +11,6 @@ export declare class SqlTranslator<TRoot extends {}, TShape> extends DataTransla
     skip(data: unknown, _: QueryOption<TShape, "skip">): TShape;
     take(data: unknown, _: QueryOption<TShape, "take">): TShape;
     sort(data: unknown, _: QueryOption<TShape, "sort">): TShape;
+    group<T>(data: unknown, option: QueryOption<T, "group">): T;
     map(data: unknown, option: QueryOption<TShape, "map">): TShape;
 }

package/dist/plugins/translators/TranslatedArrayValue.d.ts

@@ -0,0 +1,6 @@
+import { ITranslatedValue } from './types';
+export declare class TranslatedArrayValue<T> implements ITranslatedValue<T> {
+    readonly value: T;
+    constructor(value: unknown);
+    forEach(callback: (item: unknown) => unknown): void;
+}

package/dist/plugins/translators/TranslatedGroupValue.d.ts

@@ -0,0 +1,6 @@
+import { ITranslatedValue } from './types';
+export declare class TranslatedGroupValue<T> implements ITranslatedValue<T> {
+    readonly value: T;
+    constructor(value: unknown);
+    forEach(callback: (item: unknown) => unknown): void;
+}

package/dist/plugins/translators/TranslatedSingleValue.d.ts

@@ -0,0 +1,6 @@
+import { ITranslatedValue } from './types';
+export declare class TranslatedSingleValue<T> implements ITranslatedValue<T> {
+    value: T;
+    constructor(value: unknown);
+    forEach(callback: (item: unknown) => unknown): void;
+}

package/dist/plugins/translators/index.d.ts

@@ -1,3 +1,7 @@
 export * from './DataTranslator';
 export * from './JsonTranslator';
 export * from './SqlTranslator';
+export * from './types';
+export * from './TranslatedArrayValue';
+export * from './TranslatedGroupValue';
+export * from './TranslatedSingleValue';

package/dist/plugins/translators/types.d.ts

@@ -0,0 +1,10 @@
+export interface ITranslatedValue<T> {
+    readonly value: T;
+    /**
+     * Iterates over items in the collection, calling the callback for each item.
+     * If the callback returns a value, that value will replace the original item in the collection.
+     *
+     * @param callback Function called for each item. If it returns a value, that value replaces the original item.
+     */
+    forEach(callback: (item: unknown) => unknown): void;
+}

package/dist/plugins/types.d.ts

@@ -2,6 +2,7 @@ import { PluginEventCallbackPartialResult, PluginEventCallbackResult } from "../
 import { QueryOptionsCollection } from "./query/QueryOptionsCollection";
 import { CompiledSchema, InferType } from '../schema';
 import { BulkPersistChanges, BulkPersistResult, SchemaCollection } from "../collections";
+import { ITranslatedValue } from "./translators";
 /**
  * Interface for a database plugin, which provides query, destroy, and bulk operations.
  */
@@ -11,7 +12,7 @@ export interface IDbPlugin {
      * @param event The query event containing schema, parent, and query operation.
      * @param done Callback with the result or error.
      */
-    query<TRoot extends {}, TShape extends any = TRoot>(event: DbPluginQueryEvent<TRoot, TShape>, done: PluginEventCallbackResult<TShape>): void;
+    query<TRoot extends {}, TShape extends any = TRoot>(event: DbPluginQueryEvent<TRoot, TShape>, done: PluginEventCallbackResult<ITranslatedValue<TShape>>): void;
     /**
      * Destroys or cleans up the plugin, closing connections or freeing resources.
      * @param done Callback with an optional error.

package/dist/schema/PropertyInfo.d.ts

@@ -1,3 +1,4 @@
+import { UnknownRecord } from '../utilities';
 import { SchemaBase } from './property/base/SchemaBase';
 import { DefaultValue, FunctionBody, PropertyDeserializer, PropertySerializer, SchemaTypes } from './types';
 /**
@@ -63,9 +64,12 @@ export declare class PropertyInfo<T extends {}> {
      * @returns {number} The number of parent properties above this property (0 for root).
      */
     get level(): number;
+    get isRenamed(): boolean;
+    get supportsDeserialization(): boolean;
     private _getPropertyChain;
     private _needsOptionalChaining;
     private _resolvePathArray;
+    getResolvedName(): string;
     /**
      * Returns an array of property names representing the path from the root to this property.
      *
@@ -96,7 +100,7 @@ export declare class PropertyInfo<T extends {}> {
      * @param instance The object instance to retrieve the value from.
      * @returns The value of the property, or null if not found.
      */
-    getValue(instance: unknown): any;
+    getValue(instance: UnknownRecord): any;
     /**
      * Sets the value of this property on the given instance, creating intermediate objects as needed.
      *
@@ -115,6 +119,7 @@ export declare class PropertyInfo<T extends {}> {
         parent: string;
         assignmentType?: AssignmentType;
         useFromPropertyName?: boolean;
+        useRemappedName?: boolean;
     }): string;
     /**
      * Returns an assignment path string for this property, optionally starting from a parent variable name.

package/dist/schema/SchemaDefinition.d.ts

@@ -9,7 +9,7 @@ export declare class SchemaDefinition<T extends {}> extends SchemaBase<T, any> {
     constructor(collectionName: string, schema: T);
     modify<R>(builder: (d: {
         function: <UU, I = never>(fn: (entity: InferType<CompiledSchema<T>>, collectionName: string, injected: I) => UU, injected?: I) => SchemaFunction<UU, I, "unmapped">;
-        computed: <UU, I = never>(fn: (entity: InferType<CompiledSchema<T>>, collectionName: string, injected: I) => UU, injected?: I) => SchemaComputed<UU, I, "unmapped">;
+        computed: <UU, I = never>(fn: (entity: InferType<CompiledSchema<T>>, collectionName: string, injected: I) => UU, injected?: I) => SchemaComputed<UU, I, "computed" | "unmapped">;
     }) => R): SchemaDefinition<R & T>;
     private _iterate;
     private createChangeTracker;

package/dist/schema/communication/broadcast.d.ts

@@ -1,9 +1,9 @@
-import { ISchemaSubscription, SchemaId, SubscriptionChanges } from "../types";
+import { CompiledSchemaCore, ISchemaSubscription, SubscriptionChanges } from "../types";
 export declare class SchemaSubscription<T extends {}> implements ISchemaSubscription<T> {
     private readonly id;
-    private readonly schemaId;
+    private readonly schema;
     private readonly createdAt;
-    constructor(schemaId: SchemaId, signal?: AbortSignal);
+    constructor(schema: CompiledSchemaCore<T>, signal?: AbortSignal);
     send(changes: SubscriptionChanges<T>): void;
     onMessage(callback: (changes: SubscriptionChanges<T>) => void): void;
     dispose(): void;