exupery-core-types 0.3.31 → 0.3.32

package/dist/Command.d.ts

@@ -1,11 +1,9 @@
-import { Query_Promise } from "./Query";
-import { Refinement_Result } from "./Refiner";
+import { Data_Preparation_Result } from "./Data_Preparation_Result";
 export type Command_Procedure<Parameters, Error, Resources> = ($r: Resources) => Command<Parameters, Error>;
 export type Command<Parameters, Error> = {
     'execute': {
-        'direct': <New_Error>(transform_error: (error: Error) => New_Error, parameters: Parameters) => Command_Promise<New_Error>;
-        'query': <New_Error>(transform_error: (error: Error) => New_Error, query: Query_Promise<Parameters, New_Error>) => Command_Promise<New_Error>;
-        'refiner': <New_Error>(transform_error: (error: Error) => New_Error, refiner: Refinement_Result<Parameters, New_Error>) => Command_Promise<New_Error>;
+        'direct': <Target_Error>(transform_error: (error: Error) => Target_Error, parameters: Parameters) => Command_Promise<Target_Error>;
+        'prepare': <Target_Error>(transform_error: (error: Error) => Target_Error, query: Data_Preparation_Result<Parameters, Target_Error>) => Command_Promise<Target_Error>;
     };
 };
 export type Command_Promise<Error> = {

package/dist/Data_Preparation_Result.d.ts

@@ -0,0 +1,3 @@
+export interface Data_Preparation_Result<Output, Error> {
+    __extract_data: (success: ($: Output) => void, error: ($: Error) => void) => void;
+}

package/dist/Data_Preparation_Result.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// query_with_result<New_Result>(
+//     query: Query<Result, New_Result, Error>
+// ): Query_Promise<New_Result, Error>
+// rework_error_with_new_query<Target_Error, Rework_Query_Error>(
+//     query: Query<Error, Target_Error, Rework_Query_Error>,
+//     transform_rework_error: (error: Rework_Query_Error) => Target_Error,
+// ): Query_Promise<Result, Target_Error>
+// query<New_Result, Target_Error>(queries: {
+//     'result': Query<Result, New_Result, Target_Error>,
+//     'error': Query<Error, New_Result, Target_Error>,
+// }): Query_Promise<New_Result, Target_Error>
+// process_result<New_Result>(
+//     processor: Processor<Result, New_Result, Error>
+// ): Query_Promise<New_Result, Error>
+// process_error<Target_Error>(
+//     processor: Processor<Error, Result, Target_Error>
+// ): Query_Promise<Result, Target_Error>
+// process<New_Result, Target_Error>($: {
+//     'result': Processor<Result, New_Result, Target_Error>,
+//     'error': Processor<Error, New_Result, Target_Error>,
+// }): Query_Promise<New_Result, Target_Error>
+// transform_result<New_Result>(
+//     transformer: (Transformer_Without_Parameters<Result, New_Result>)
+// ): Query_Promise<New_Result, Error>
+// transform_error<Target_Error>(
+//     transformer: Transformer_Without_Parameters<Error, Target_Error>
+// ): Query_Promise<Result, Target_Error>
+// transform<New_Result, Target_Error>($: {
+//     'result': Transformer_Without_Parameters<Result, New_Result>,
+//     'error': Transformer_Without_Parameters<Error, Target_Error>,
+// }): Query_Promise<New_Result, Target_Error>
+// __start(
+//     on_success: ($: Result) => void,
+//     on_error: ($: Error) => void
+// ): void
+//     export interface Process_Result<Output, Error> {
+//     'transform': <New_Output>(
+//         transformer: Transformer_Without_Parameters<Output, New_Output>
+//     ) => Process_Result<New_Output, Error>
+//     'transform error': <Target_Error>(
+//         transformer: Transformer_Without_Parameters<Error, Target_Error>
+//     ) => Process_Result<Output, Target_Error>
+//     'transform with parameters': <New_Output, Parameters>(
+//         transformer: Transformer_With_Parameters<Output, Parameters, New_Output>,
+//         parameters: Parameters
+//     ) => Process_Result<New_Output, Error>
+//     'refine': <New_Output, Refine_Error>(
+//         refiner: Refiner_Without_Parameters<Output, New_Output, Refine_Error>,
+//         map_error: ($: Refine_Error) => Error
+//     ) => Process_Result<New_Output, Error>
+//     'refine with parameters': <New_Output, Parameters, Refine_Error>(
+//         refiner: Refiner_With_Parameters<Output, Parameters, New_Output, Refine_Error>,
+//         parameters: Parameters,
+//         map_error: ($: Refine_Error) => Error
+//     ) => Process_Result<New_Output, Error>
+//     __extract_data: (
+//         success: ($: Output) => void,
+//         error: ($: Error) => void
+//     ) => void
+// }
+// export interface Refinement_Result<T, E> {
+//     /**
+//      * @param set what to do when the value was set, returns the new type
+//      * @param not_set  what to do when the value was not set, returns the new type
+//      */
+//     process(
+//         success: ($: T) => void,
+//         error: ($: E) => void,
+//     ): void
+//     map<NT, NE>(
+//         handle_value: ($: T) => NT,
+//         handle_error: ($: E) => NE
+//     ): Refinement_Result<NT, NE>
+//     map_result<NT>(
+//         handle_value: ($: T) => NT,
+//     ): Refinement_Result<NT, E>
+//     transform<NT>(
+//         handle_value: ($: T) => NT,
+//         handle_error: ($: E) => NT
+//     ): NT
+//     transform_error<NE>(
+//         handle_error: ($: E) => NE
+//     ): Refinement_Result<T, NE>
+//     with_result<NT>(
+//         handle_value: ($: T) => Refinement_Result<NT, E>,
+//     ): Refinement_Result<NT, E>
+// }

package/dist/Data_Preparer.d.ts

@@ -0,0 +1,3 @@
+import { Data_Preparation_Result } from "./Data_Preparation_Result";
+export type Data_Preparer<Input, Output, Error> = ($: Input) => Data_Preparation_Result<Output, Error>;
+export type Data_Preparer_With_Parameters<Input, Parameters, Output, Error> = ($: Input, $p: Parameters) => Data_Preparation_Result<Output, Error>;

package/dist/Query.d.ts

@@ -1,25 +1,2 @@
-import { Processor } from "./Processor";
-import { Transformer_Without_Parameters } from "./Transformer";
-export type Query_Procedure<Parameters, Result, Error, Resources> = ($r: Resources) => Query<Parameters, Result, Error>;
-export type Query<Parameters, Result, Error> = ($: Parameters) => Query_Promise<Result, Error>;
-export type Query_Promise<Result, Error> = {
-    query_with_result<New_Result>(query: Query<Result, New_Result, Error>): Query_Promise<New_Result, Error>;
-    rework_error_with_new_query<New_Error, Rework_Query_Error>(query: Query<Error, New_Error, Rework_Query_Error>, transform_rework_error: (error: Rework_Query_Error) => New_Error): Query_Promise<Result, New_Error>;
-    query<New_Result, New_Error>(queries: {
-        'result': Query<Result, New_Result, New_Error>;
-        'error': Query<Error, New_Result, New_Error>;
-    }): Query_Promise<New_Result, New_Error>;
-    process_result<New_Result>(processor: Processor<Result, New_Result, Error>): Query_Promise<New_Result, Error>;
-    process_error<New_Error>(processor: Processor<Error, Result, New_Error>): Query_Promise<Result, New_Error>;
-    process<New_Result, New_Error>($: {
-        'result': Processor<Result, New_Result, New_Error>;
-        'error': Processor<Error, New_Result, New_Error>;
-    }): Query_Promise<New_Result, New_Error>;
-    transform_result<New_Result>(transformer: (Transformer_Without_Parameters<Result, New_Result>)): Query_Promise<New_Result, Error>;
-    transform_error<New_Error>(transformer: Transformer_Without_Parameters<Error, New_Error>): Query_Promise<Result, New_Error>;
-    transform<New_Result, New_Error>($: {
-        'result': Transformer_Without_Parameters<Result, New_Result>;
-        'error': Transformer_Without_Parameters<Error, New_Error>;
-    }): Query_Promise<New_Result, New_Error>;
-    __start(on_success: ($: Result) => void, on_error: ($: Error) => void): void;
-};
+import { Data_Preparer } from "./Data_Preparer";
+export type Query_Procedure<Parameters, Result, Error, Resources> = ($r: Resources) => Data_Preparer<Parameters, Result, Error>;

package/dist/index.d.ts

@@ -4,8 +4,7 @@ export * from "./Dictionary";
 export * from "./Lookup";
 export * from "./Optional_Value";
 export * from "./Command";
-export * from "./Processor";
-export * from "./Process_Result";
+export * from "./Data_Preparer";
+export * from "./Data_Preparation_Result";
 export * from "./Query";
-export * from "./Refiner";
 export * from "./Transformer";

package/dist/index.js

@@ -20,8 +20,7 @@ __exportStar(require("./Dictionary"), exports);
 __exportStar(require("./Lookup"), exports);
 __exportStar(require("./Optional_Value"), exports);
 __exportStar(require("./Command"), exports);
-__exportStar(require("./Processor"), exports);
-__exportStar(require("./Process_Result"), exports);
+__exportStar(require("./Data_Preparer"), exports);
+__exportStar(require("./Data_Preparation_Result"), exports);
 __exportStar(require("./Query"), exports);
-__exportStar(require("./Refiner"), exports);
 __exportStar(require("./Transformer"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-types",
-  "version": "0.3.31",
+  "version": "0.3.32",
   "license": "Apache-2.0",
   "author": "Corno",
   "description": "core types for Exupery",

package/dist/Process_Result.d.ts

@@ -1,10 +0,0 @@
-import { Refiner_With_Parameters, Refiner_Without_Parameters } from "./Refiner";
-import { Transformer_With_Parameters, Transformer_Without_Parameters } from "./Transformer";
-export interface Process_Result<Output, Error> {
-    'transform': <New_Output>(transformer: Transformer_Without_Parameters<Output, New_Output>) => Process_Result<New_Output, Error>;
-    'transform error': <New_Error>(transformer: Transformer_Without_Parameters<Error, New_Error>) => Process_Result<Output, New_Error>;
-    'transform with parameters': <New_Output, Parameters>(transformer: Transformer_With_Parameters<Output, Parameters, New_Output>, parameters: Parameters) => Process_Result<New_Output, Error>;
-    'refine': <New_Output, Refine_Error>(refiner: Refiner_Without_Parameters<Output, New_Output, Refine_Error>, map_error: ($: Refine_Error) => Error) => Process_Result<New_Output, Error>;
-    'refine with parameters': <New_Output, Parameters, Refine_Error>(refiner: Refiner_With_Parameters<Output, Parameters, New_Output, Refine_Error>, parameters: Parameters, map_error: ($: Refine_Error) => Error) => Process_Result<New_Output, Error>;
-    __extract_data: (success: ($: Output) => void, error: ($: Error) => void) => void;
-}

package/dist/Processor.d.ts

@@ -1,2 +0,0 @@
-import { Process_Result } from "./Process_Result";
-export type Processor<Input, Output, Error> = ($: Input) => Process_Result<Output, Error>;

package/dist/Processor.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Refiner.d.ts

@@ -1,14 +0,0 @@
-export interface Refinement_Result<T, E> {
-    /**
-     * @param set what to do when the value was set, returns the new type
-     * @param not_set  what to do when the value was not set, returns the new type
-     */
-    process(success: ($: T) => void, error: ($: E) => void): void;
-    map<NT, NE>(handle_value: ($: T) => NT, handle_error: ($: E) => NE): Refinement_Result<NT, NE>;
-    map_result<NT>(handle_value: ($: T) => NT): Refinement_Result<NT, E>;
-    transform<NT>(handle_value: ($: T) => NT, handle_error: ($: E) => NT): NT;
-    transform_error<NE>(handle_error: ($: E) => NE): Refinement_Result<T, NE>;
-    with_result<NT>(handle_value: ($: T) => Refinement_Result<NT, E>): Refinement_Result<NT, E>;
-}
-export type Refiner_With_Parameters<In, Parameters, Out, Error> = ($: In, $p: Parameters) => Refinement_Result<Out, Error>;
-export type Refiner_Without_Parameters<In, Out, Error> = ($: In) => Refinement_Result<Out, Error>;

package/dist/Refiner.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });