@duplojs/http 0.7.1 → 0.7.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/core/clean/entity.cjs +19 -28
  2. package/dist/core/clean/entity.d.ts +9 -9
  3. package/dist/core/clean/entity.mjs +20 -29
  4. package/package.json +2 -2
package/dist/core/clean/entity.cjs CHANGED
@@ -1,33 +1,24 @@
1
1
  'use strict';
2
2
 
3
3
  var utils = require('@duplojs/utils');
4
- var clean = require('@duplojs/utils/clean');
4
+ require('@duplojs/utils/clean');
5
5
 
6
- function propertiesDefinitionToSchema(definition, method) {
7
- return utils.pipe(definition, utils.P.when(clean.newTypeHandlerKind.has, (value) => value[method]()), utils.P.when(utils.isType("array"), utils.innerPipe(utils.A.map((element) => element[method]()), (options) => {
8
- utils.asserts(options, utils.A.minElements(1));
9
- return utils.DP.union(options);
10
- })), utils.P.otherwise((definition) => utils.pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
11
- if (definition.inArray) {
12
- return utils.pipe(dataParser, utils.DP.array, (dataParser) => typeof definition.inArray === "object"
13
- && typeof definition.inArray.min === "number"
14
- ? dataParser.addChecker(utils.DP.checkerArrayMin(definition.inArray.min))
15
- : dataParser, (dataParser) => typeof definition.inArray === "object"
16
- && typeof definition.inArray.max === "number"
17
- ? dataParser.addChecker(utils.DP.checkerArrayMax(definition.inArray.max))
18
- : dataParser);
19
- }
20
- return dataParser;
21
- }, (dataParser) => definition.nullable === true
22
- ? utils.DP.nullable(dataParser)
23
- : dataParser)));
24
- }
25
- clean.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), utils.O.fromEntries, utils.DPE.object));
26
- clean.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
27
- ? {
28
- ...shape,
29
- _entityName: typeof params.addEntityName === "string"
30
- ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
31
- : utils.DP.literal(self.name),
6
+ utils.C.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => {
7
+ if (typeof keys === "string") {
8
+ return utils.C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toExtractParser());
9
+ }
10
+ return utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, utils.C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toExtractParser()))), utils.O.fromEntries, utils.DPE.object);
11
+ });
12
+ utils.C.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => {
13
+ if (typeof keys === "string") {
14
+ return utils.C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toEndpointSchema());
32
15
  }
33
- : shape, utils.DPE.object));
16
+ return utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, utils.C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toEndpointSchema()))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
17
+ ? {
18
+ ...shape,
19
+ _entityName: typeof params.addEntityName === "string"
20
+ ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
21
+ : utils.DP.literal(self.name),
22
+ }
23
+ : shape, utils.DPE.object);
24
+ });
package/dist/core/clean/entity.d.ts CHANGED
@@ -1,20 +1,20 @@
1
- import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends } from "@duplojs/utils";
2
- import { type EntityRawProperties, type EntityProperties, type EntityPropertiesDefinition } from "@duplojs/utils/clean";
1
+ import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends, C, type MaybeArray } from "@duplojs/utils";
2
+ import "@duplojs/utils/clean";
3
3
  interface ToEndpointSchemaParams {
4
4
  addEntityName?: boolean | string;
5
5
  }
6
6
  declare module "@duplojs/utils/clean" {
7
- interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> {
8
- toExtractParser<GenericEntityProperties extends EntityProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityProperties = keyof GenericEntityProperties>(keys?: GenericKey[]): ReturnType<typeof DPE.object<{
9
- [Prop in GenericKey]: DP.Contract<GenericEntityProperties[Prop], unknown>;
10
- }>>;
11
- toEndpointSchema<GenericEntityRawProperties extends EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityRawProperties = keyof GenericEntityRawProperties, const GenericParams extends ToEndpointSchemaParams = {}>(keys?: GenericKey[], params?: GenericParams | ToEndpointSchemaParams): ReturnType<typeof DPE.object<SimplifyTopLevel<{
12
- [Prop in GenericKey]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
7
+ interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends C.EntityPropertiesDefinition = C.EntityPropertiesDefinition> {
8
+ toExtractParser<GenericEntityProperties extends C.EntityProperties<GenericPropertiesDefinition>, const GenericKey extends MaybeArray<keyof GenericEntityProperties> = readonly (keyof GenericEntityProperties)[]>(keys?: GenericKey): GenericKey extends readonly any[] ? ReturnType<typeof DPE.object<SimplifyTopLevel<{
9
+ [Prop in GenericKey[number]]: DP.Contract<GenericEntityProperties[Prop], unknown>;
10
+ }>>> : DP.Contract<GenericEntityProperties[Extract<GenericKey, string>], unknown>;
11
+ toEndpointSchema<GenericEntityRawProperties extends C.EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends MaybeArray<keyof GenericEntityRawProperties> = readonly (keyof GenericEntityRawProperties)[], const GenericParams extends (ToEndpointSchemaParams) = {}>(keys?: GenericKey, params?: (GenericParams | ToEndpointSchemaParams) & (GenericKey extends string ? never : unknown)): GenericKey extends readonly any[] ? ReturnType<typeof DPE.object<SimplifyTopLevel<{
12
+ [Prop in GenericKey[number]]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
13
13
  } & (IsEqual<GenericParams["addEntityName"], true> extends true ? {
14
14
  [Prop in "_entityName"]: DP.Contract<GenericName, unknown>;
15
15
  } : {}) & (IsExtends<GenericParams["addEntityName"], string> extends true ? {
16
16
  [Prop in "_entityName"]: DP.Contract<`${GenericName}/${GenericParams["addEntityName"]}`, unknown>;
17
- } : {})>>>;
17
+ } : {})>>> : DP.Contract<GenericEntityRawProperties[Extract<GenericKey, string>], unknown>;
18
18
  }
19
19
  }
20
20
  export {};
package/dist/core/clean/entity.mjs CHANGED
@@ -1,31 +1,22 @@
1
- import { pipe, P, isType, innerPipe, A, asserts, DP, O, DPE } from '@duplojs/utils';
2
- import { newTypeHandlerKind, createEntity } from '@duplojs/utils/clean';
1
+ import { C, pipe, O, A, DPE, DP } from '@duplojs/utils';
2
+ import '@duplojs/utils/clean';
3
3
 
4
- function propertiesDefinitionToSchema(definition, method) {
5
- return pipe(definition, P.when(newTypeHandlerKind.has, (value) => value[method]()), P.when(isType("array"), innerPipe(A.map((element) => element[method]()), (options) => {
6
- asserts(options, A.minElements(1));
7
- return DP.union(options);
8
- })), P.otherwise((definition) => pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
9
- if (definition.inArray) {
10
- return pipe(dataParser, DP.array, (dataParser) => typeof definition.inArray === "object"
11
- && typeof definition.inArray.min === "number"
12
- ? dataParser.addChecker(DP.checkerArrayMin(definition.inArray.min))
13
- : dataParser, (dataParser) => typeof definition.inArray === "object"
14
- && typeof definition.inArray.max === "number"
15
- ? dataParser.addChecker(DP.checkerArrayMax(definition.inArray.max))
16
- : dataParser);
17
- }
18
- return dataParser;
19
- }, (dataParser) => definition.nullable === true
20
- ? DP.nullable(dataParser)
21
- : dataParser)));
22
- }
23
- createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), O.fromEntries, DPE.object));
24
- createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
25
- ? {
26
- ...shape,
27
- _entityName: typeof params.addEntityName === "string"
28
- ? DP.literal(`${self.name}/${params.addEntityName}`)
29
- : DP.literal(self.name),
4
+ C.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => {
5
+ if (typeof keys === "string") {
6
+ return C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toExtractParser());
7
+ }
8
+ return pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toExtractParser()))), O.fromEntries, DPE.object);
9
+ });
10
+ C.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => {
11
+ if (typeof keys === "string") {
12
+ return C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toEndpointSchema());
30
13
  }
31
- : shape, DPE.object));
14
+ return pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toEndpointSchema()))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
15
+ ? {
16
+ ...shape,
17
+ _entityName: typeof params.addEntityName === "string"
18
+ ? DP.literal(`${self.name}/${params.addEntityName}`)
19
+ : DP.literal(self.name),
20
+ }
21
+ : shape, DPE.object);
22
+ });
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@duplojs/http",
3
- "version": "0.7.1",
3
+ "version": "0.7.4",
4
4
  "author": "mathcovax",
5
5
  "license": "MIT",
6
6
  "type": "module",
@@ -67,7 +67,7 @@
67
67
  "peerDependencies": {
68
68
  "@duplojs/data-parser-tools": ">=0.2.8 <1.0.0",
69
69
  "@duplojs/server-utils": ">=0.2.0 <1.0.0",
70
- "@duplojs/utils": ">=1.5.6 <2.0.0"
70
+ "@duplojs/utils": ">=1.5.8 <2.0.0"
71
71
  },
72
72
  "devDependencies": {
73
73
  "@commitlint/cli": "19.8.1",