@strapi/strapi 4.12.6 → 4.13.0-alpha.0

package/dist/services/entity-service/types/params/filters/index.d.ts

@@ -0,0 +1,44 @@
+import type { Attribute, Common, Utils } from '../../../../../types';
+import type * as Operator from './operators';
+import type * as AttributeUtils from '../attributes';
+export { Operator };
+/**
+ * Filter representation for nested attributes
+ */
+type NestedAttributeCondition<TSchemaUID extends Common.UID.Schema, TAttributeName extends Attribute.GetKeys<TSchemaUID>> = ObjectNotation<Utils.Guard.Never<Attribute.GetTarget<TSchemaUID, TAttributeName>, Common.UID.Schema>>;
+/**
+ * Filter representation for scalar attributes
+ */
+type AttributeCondition<TSchemaUID extends Common.UID.Schema, TAttributeName extends Attribute.GetKeys<TSchemaUID>> = Utils.Expression.If<Utils.Expression.IsNotNever<TAttributeName>, AttributeUtils.GetValue<Attribute.Get<TSchemaUID, TAttributeName>>, AttributeUtils.ScalarValues> extends infer TAttributeValue ? TAttributeValue | ({
+    [TIter in Operator.BooleanValue]?: boolean;
+} & {
+    [TIter in Operator.DynamicValue]?: TAttributeValue;
+} & {
+    [TIter in Operator.DynamicArrayValue]?: TAttributeValue[];
+} & {
+    [TIter in Operator.DynamicBoundValue]?: [TAttributeValue, TAttributeValue];
+} & {
+    [TIter in Operator.Logical]?: AttributeCondition<TSchemaUID, TAttributeName>;
+} & {
+    [TIter in Operator.Group]?: AttributeCondition<TSchemaUID, TAttributeName>[];
+}) : never;
+/**
+ * Tree representation of a Strapi filter for a given schema UID
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
+    [TIter in Operator.Group]?: ObjectNotation<TSchemaUID>[];
+} & {
+    [TIter in Operator.Logical]?: ObjectNotation<TSchemaUID>;
+} & ([AttributeUtils.GetScalarKeys<TSchemaUID>, AttributeUtils.GetNestedKeys<TSchemaUID>] extends [
+    infer TScalarKeys extends AttributeUtils.GetScalarKeys<TSchemaUID>,
+    infer TNestedKeys extends AttributeUtils.GetNestedKeys<TSchemaUID>
+] ? Utils.Expression.If<Utils.Expression.And<Utils.Expression.IsNotNever<TScalarKeys>, Utils.Expression.IsNotNever<TNestedKeys>>, {
+    [TIter in TScalarKeys]?: AttributeCondition<TSchemaUID, TIter>;
+} | {
+    [TIter in TNestedKeys]?: NestedAttributeCondition<TSchemaUID, TIter>;
+}, {
+    [TKey in string]?: AttributeCondition<TSchemaUID, never>;
+} | {
+    [TKey in string]?: NestedAttributeCondition<TSchemaUID, never>;
+}> : never);
+export type Any<TSchemaUID extends Common.UID.Schema> = ObjectNotation<TSchemaUID>;

package/dist/services/entity-service/types/params/filters/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/services/entity-service/types/params/filters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/services/entity-service/types/params/filters/index.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/filters/operators.d.ts

@@ -0,0 +1,8 @@
+export type Array = '$in' | '$notIn' | '$between';
+export type Group = '$and' | '$or';
+export type Logical = '$not';
+export type BooleanValue = '$null' | '$notNull';
+export type DynamicValue = '$eq' | '$eqi' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$startsWith' | '$endsWith' | '$startsWithi' | '$endsWithi' | '$contains' | '$notContains' | '$containsi' | '$notContainsi';
+export type DynamicArrayValue = '$in' | '$notIn';
+export type DynamicBoundValue = '$between';
+export type Where = BooleanValue | DynamicValue | DynamicArrayValue | DynamicBoundValue;

package/dist/services/entity-service/types/params/filters/operators.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=operators.js.map

package/dist/services/entity-service/types/params/filters/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sourceRoot":"","sources":["../../../../../../src/services/entity-service/types/params/filters/operators.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/index.d.ts

@@ -0,0 +1,132 @@
+import type { Common, Utils } from '../../../../types';
+import type { GetPluginParams } from '..';
+import type * as Sort from './sort';
+import type * as Pagination from './pagination';
+import type * as Fields from './fields';
+import type * as Filters from './filters';
+import type * as Populate from './populate';
+import type * as PublicationState from './publication-state';
+import type * as Data from './data';
+import type * as Search from './search';
+import type * as Attribute from './attributes';
+export type Pick<TSchemaUID extends Common.UID.Schema, TKind extends Kind> = Utils.Expression.MatchAllIntersect<[
+    [
+        HasMember<TKind, 'sort'>,
+        {
+            sort?: Sort.Any<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'sort:string'>,
+        {
+            sort?: Sort.StringNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'sort:array'>,
+        {
+            sort?: Sort.ArrayNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'sort:object'>,
+        {
+            sort?: Sort.ObjectNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'fields'>,
+        {
+            fields?: Fields.Any<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'fields:string'>,
+        {
+            fields?: Fields.StringNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'fields:array'>,
+        {
+            fields?: Fields.ArrayNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'filters'>,
+        {
+            filters?: Filters.Any<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'populate'>,
+        {
+            populate?: Populate.Any<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'populate:string'>,
+        {
+            populate?: Populate.StringNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'populate:array'>,
+        {
+            populate?: Populate.ArrayNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'populate:object'>,
+        {
+            populate?: Populate.ObjectNotation<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'pagination'>,
+        Pagination.Any
+    ],
+    [
+        HasMember<TKind, 'pagination:offset'>,
+        Pagination.OffsetNotation
+    ],
+    [
+        HasMember<TKind, 'pagination:page'>,
+        Pagination.PageNotation
+    ],
+    [
+        HasMember<TKind, 'publicationState'>,
+        PublicationState.For<TSchemaUID>
+    ],
+    [
+        HasMember<TKind, 'plugin'>,
+        GetPluginParams<TSchemaUID>
+    ],
+    [
+        HasMember<TKind, 'data'>,
+        {
+            data?: Data.Input<TSchemaUID>;
+        }
+    ],
+    [
+        HasMember<TKind, 'data:partial'>,
+        {
+            data?: Partial<Data.Input<TSchemaUID>>;
+        }
+    ],
+    [
+        HasMember<TKind, 'files'>,
+        {
+            files?: unknown;
+        }
+    ],
+    [
+        HasMember<TKind, '_q'>,
+        {
+            _q?: Search.Q;
+        }
+    ]
+]>;
+export type Kind = 'sort' | 'sort:string' | 'sort:array' | 'sort:object' | 'fields' | 'fields:string' | 'fields:array' | 'filters' | 'populate' | 'populate:string' | 'populate:array' | 'populate:object' | 'pagination' | 'pagination:offset' | 'pagination:page' | 'publicationState' | 'plugin' | 'data' | 'data:partial' | 'files' | '_q';
+type HasMember<TValue extends Kind, TTest extends Kind> = Utils.Expression.Extends<TTest, TValue>;
+export type { Sort, Pagination, Fields, Filters, Populate, PublicationState, Data, Attribute };

package/dist/services/entity-service/types/params/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/services/entity-service/types/params/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/services/entity-service/types/params/index.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/pagination.d.ts

@@ -0,0 +1,10 @@
+import type { Utils } from '../../../../types';
+export type PageNotation = {
+    page?: number;
+    pageSize?: number;
+};
+export type OffsetNotation = {
+    start?: number;
+    limit?: number;
+};
+export type Any = Utils.XOR<PageNotation, OffsetNotation>;

package/dist/services/entity-service/types/params/pagination.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=pagination.js.map

package/dist/services/entity-service/types/params/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","sourceRoot":"","sources":["../../../../../src/services/entity-service/types/params/pagination.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/populate.d.ts

@@ -0,0 +1,68 @@
+import type { Attribute, Common, Utils } from '../../../../types';
+import type { Params } from '..';
+/**
+ * Wildcard notation for populate
+ *
+ * To populate all the root level relations
+ */
+export type WildcardNotation = '*';
+/**
+ * Union of all possible string representation for populate
+ *
+ * @example
+ * type A = 'image'; // ✅
+ * type B = 'image,component'; // ✅
+ * type c = '*'; // ✅
+ * type D = 'populatableField'; // ✅
+ * type E = '<random_string>'; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> = WildcardNotation | Utils.Guard.Never<Attribute.GetPopulatableKeys<TSchemaUID>, string> | `${string},${string}` | `${string}.${string}`;
+/**
+ * Array notation for populate
+ *
+ * @example
+ * type A = ['image']; // ✅
+ * type B = ['image', 'component']; // ✅
+ * type C = ['populatableField']; // ✅
+ * type D = ['<random_string>']; // ❌
+ * type E = ['*']; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Exclude<StringNotation<TSchemaUID>, WildcardNotation>[];
+type GetPopulatableKeysWithTarget<TSchemaUID extends Common.UID.Schema> = Extract<Attribute.GetPopulatableKeys<TSchemaUID>, Attribute.GetKeysWithTarget<TSchemaUID>>;
+type GetPopulatableKeysWithoutTarget<TSchemaUID extends Common.UID.Schema> = Exclude<Attribute.GetPopulatableKeys<TSchemaUID>, GetPopulatableKeysWithTarget<TSchemaUID>>;
+/**
+ * Fragment populate notation for polymorphic attributes
+ */
+export type Fragment<TMaybeTargets extends Common.UID.Schema> = {
+    on?: {
+        [TSchemaUID in TMaybeTargets]?: boolean | NestedParams<TSchemaUID>;
+    };
+};
+type PopulateClause<TSchemaUID extends Common.UID.Schema, TKeys extends Attribute.GetPopulatableKeys<TSchemaUID>> = {
+    [TKey in TKeys]?: boolean | NestedParams<Attribute.GetTarget<TSchemaUID, TKey>>;
+};
+/**
+ * Object notation for populate
+ *
+ * @example
+ * type A = { image: true }; // ✅
+ * type B = { image: { fields: ['url', 'provider'] } }; // ✅
+ * type C = { populatableField: { populate: { nestedPopulatableField: true } } }; // ✅
+ * type D = { dynamic_zone: { on: { comp_A: { fields: ['name', 'price_a'] }, comp_B: { fields: ['name', 'price_b'] } } } }; // ✅
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = [
+    GetPopulatableKeysWithTarget<TSchemaUID>,
+    GetPopulatableKeysWithoutTarget<TSchemaUID>
+] extends [
+    infer TKeysWithTarget extends Attribute.GetPopulatableKeys<TSchemaUID>,
+    infer TKeysWithoutTarget extends Attribute.GetPopulatableKeys<TSchemaUID>
+] ? Utils.Expression.If<Utils.Expression.And<Common.AreSchemaRegistriesExtended, Utils.Expression.DoesNotExtends<Common.UID.Schema, TSchemaUID>>, Utils.Expression.If<Utils.Expression.IsNotNever<TKeysWithTarget>, PopulateClause<TSchemaUID, TKeysWithTarget>> | Utils.Expression.If<Utils.Expression.IsNotNever<TKeysWithoutTarget>, {
+    [TKey in TKeysWithoutTarget]?: boolean | Fragment<Utils.Guard.Never<Attribute.GetMorphTargets<TSchemaUID, TKey>, Common.UID.Schema>> | NestedParams<Common.UID.Schema>;
+}>, {
+    [TKey in string]?: boolean | NestedParams<Common.UID.Schema>;
+} | {
+    [TKey in string]?: boolean | Fragment<Common.UID.Schema> | NestedParams<Common.UID.Schema>;
+}> : never;
+export type NestedParams<TSchemaUID extends Common.UID.Schema> = Params.Pick<TSchemaUID, 'fields' | 'filters' | 'populate' | 'sort' | 'plugin' | 'publicationState'>;
+export type Any<TSchemaUID extends Common.UID.Schema> = StringNotation<TSchemaUID> | ArrayNotation<TSchemaUID> | ObjectNotation<TSchemaUID>;
+export {};

package/dist/services/entity-service/types/params/populate.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=populate.js.map

package/dist/services/entity-service/types/params/populate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"populate.js","sourceRoot":"","sources":["../../../../../src/services/entity-service/types/params/populate.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/publication-state.d.ts

@@ -0,0 +1,15 @@
+import type { Common, Utils } from '../../../../types';
+export type Kind = 'preview' | 'live';
+export type IsEnabled<TSchemaUID extends Common.UID.Schema> = Utils.Expression.MatchFirst<[
+    [
+        Common.UID.IsContentType<TSchemaUID>,
+        Utils.Expression.IsTrue<Common.Schemas[TSchemaUID]['options']['draftAndPublish']>
+    ],
+    [
+        Utils.Expression.And<Utils.Expression.Not<Utils.Expression.Extends<TSchemaUID, Common.UID.ContentType>>, Common.UID.IsComponent<TSchemaUID>>,
+        Utils.Expression.False
+    ]
+], Utils.Expression.BooleanValue>;
+export type For<TSchemaUID extends Common.UID.Schema> = IsEnabled<TSchemaUID> extends infer TEnabled ? Utils.Expression.If<Utils.Expression.Or<Utils.Expression.IsTrue<TEnabled>, Utils.Expression.Extends<Utils.Expression.BooleanValue, TEnabled>>, {
+    publicationState?: Kind;
+}, {}> : never;

package/dist/services/entity-service/types/params/publication-state.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=publication-state.js.map

package/dist/services/entity-service/types/params/publication-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publication-state.js","sourceRoot":"","sources":["../../../../../src/services/entity-service/types/params/publication-state.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/search.d.ts

@@ -0,0 +1 @@
+export type Q = string;

package/dist/services/entity-service/types/params/search.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=search.js.map

package/dist/services/entity-service/types/params/search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.js","sourceRoot":"","sources":["../../../../../src/services/entity-service/types/params/search.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/params/sort.d.ts

@@ -0,0 +1,84 @@
+import type { Attribute, Common, Utils } from '../../../../types';
+export declare namespace OrderKind {
+    type Asc = 'asc';
+    type Desc = 'desc';
+    type Any = Asc | Desc;
+}
+/**
+ * Single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'description'; // ✅
+ * type C = 'title:asc'; // ❌
+ * type D = 'title,description'; // ❌
+ */
+type SingleAttribute<TSchemaUID extends Common.UID.Schema> = 'id' | Utils.Guard.Never<string & Attribute.GetNonPopulatableKeys<TSchemaUID>, string>;
+/**
+ * Ordered single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ❌
+ * type D = 'title,description'; // ❌
+ */
+type OrderedSingleAttribute<TSchemaUID extends Common.UID.Schema> = `${SingleAttribute<TSchemaUID>}:${OrderKind.Any}`;
+/**
+ * Union of all possible string representation for a sort
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description:asc'; // ✅
+ * type E = [42]; // ❌
+ * type F = { title: 'asc' }; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> = SingleAttribute<TSchemaUID> | OrderedSingleAttribute<TSchemaUID> | `${string},${string}`;
+/**
+ * Array notation for a sort
+ *
+ * @example
+ * type A = ['title:asc', 'description']; // ✅
+ * type B = ['title']; // ✅
+ * type C = ['count', 'title,description:asc']; // ✅
+ * type D = { title: 'asc' }; // ❌
+ * type E = [42]; // ❌
+ * type F = 'title'; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Any<TSchemaUID>[];
+/**
+ * Object notation for a sort
+ *
+ * @example
+ * type A = { title: 'asc' }; // ✅
+ * type B = { title: 'asc', description: 'desc' }; // ✅
+ * type C = { title: 'asc', author: { name: 'asc' } }; // ✅
+ * type D = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
+ * type E = ['title']; // ❌
+ * type F = 'title'; // ❌
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
+    [key in SingleAttribute<TSchemaUID>]?: OrderKind.Any;
+} & {
+    [key in Attribute.GetKeysWithTarget<TSchemaUID>]?: ObjectNotation<Attribute.GetTarget<TSchemaUID, key>>;
+};
+/**
+ * Represents any notation for a sort (string, array, object)
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description:asc'; // ✅
+ * type E = ['title:asc', 'description']; // ✅
+ * type F = ['title']; // ✅
+ * type G = ['count', 'title,description:asc']; // ✅
+ * type H = { title: 'asc' }; // ✅
+ * type I = { title: 'asc', description: 'desc' }; // ✅
+ * type J = { title: 'asc', author: { name: 'asc' } }; // ✅
+ * type K = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
+ */
+export type Any<TSchemaUID extends Common.UID.Schema> = StringNotation<TSchemaUID> | ArrayNotation<TSchemaUID> | ObjectNotation<TSchemaUID>;
+export {};

package/dist/services/entity-service/types/params/sort.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=sort.js.map

package/dist/services/entity-service/types/params/sort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../../../../src/services/entity-service/types/params/sort.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Common, Plugin, Utils, Shared } from '../../../types';
+export type GetPluginParams<TSchemaUID extends Common.UID.Schema> = Utils.Guard.OfTypes<[
+    never,
+    undefined
+], Utils.Object.Values<{
+    [TPluginName in keyof Shared.EntityServicePluginParams]: Shared.EntityServicePluginParams[TPluginName] extends infer TParam ? Utils.Expression.If<Plugin.IsEnabled<TPluginName, TSchemaUID>, TParam> : never;
+}>, unknown>;

package/dist/services/entity-service/types/plugin.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=plugin.js.map

package/dist/services/entity-service/types/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../../../src/services/entity-service/types/plugin.ts"],"names":[],"mappings":""}

package/dist/services/entity-service/types/result.d.ts

@@ -0,0 +1,88 @@
+import type { Attribute, Common, Utils } from '../../../types';
+import type { Params } from './index';
+type Pagination = {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+};
+type AnyEntity = {
+    id: Params.Attribute.ID;
+} & {
+    [key: string]: any;
+};
+export type Result<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = Utils.Expression.If<Common.AreSchemaRegistriesExtended, GetValues<TSchemaUID, Utils.Guard.Never<ExtractFields<TSchemaUID, TParams['fields']>, Attribute.GetNonPopulatableKeys<TSchemaUID>>, ExtractPopulate<TSchemaUID, TParams['populate']>>, AnyEntity>;
+export type Entity<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = Utils.Expression.If<Common.AreSchemaRegistriesExtended, GetValues<TSchemaUID, Utils.Guard.Never<ExtractFields<TSchemaUID, TParams['fields']>, Attribute.GetNonPopulatableKeys<TSchemaUID>>, Utils.Guard.Never<ExtractPopulate<TSchemaUID, TParams['populate']>, Attribute.GetPopulatableKeys<TSchemaUID>>>, AnyEntity>;
+export type PartialEntity<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = Partial<Entity<TSchemaUID, TParams>>;
+export type PaginatedResult<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = {
+    results: Entity<TSchemaUID, TParams>[];
+    pagination: Pagination;
+};
+/**
+ * Attribute.GetValues override with extended values
+ *
+ * TODO: Make it recursive for populatable fields
+ */
+export type GetValues<TSchemaUID extends Common.UID.Schema, TFields extends Attribute.GetKeys<TSchemaUID>, TPopulate extends Attribute.GetKeys<TSchemaUID>> = Utils.Expression.If<Common.AreSchemaRegistriesExtended, Utils.Guard.Never<TFields | TPopulate, Attribute.GetKeys<TSchemaUID>> extends infer TKeys ? Attribute.GetValues<TSchemaUID, TKeys> : never, AnyEntity>;
+type ExtractFields<TSchemaUID extends Common.UID.Schema, TFields extends Params.Fields.Any<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.Or<Utils.Expression.StrictEqual<TFields, Params.Fields.Any<TSchemaUID>>, Utils.Expression.IsNever<TFields>>,
+        never
+    ],
+    [
+        Utils.Expression.Extends<TFields, Params.Fields.StringNotation<TSchemaUID>>,
+        ParseStringFields<TSchemaUID, Utils.Cast<TFields, Params.Fields.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TFields, Params.Fields.ArrayNotation<TSchemaUID>>,
+        ParseStringFields<TSchemaUID, Utils.Cast<Utils.Array.Values<Utils.Cast<TFields, Params.Fields.ArrayNotation<TSchemaUID>>>, Params.Fields.StringNotation<TSchemaUID>>>
+    ]
+]>;
+type ParseStringFields<TSchemaUID extends Common.UID.Schema, TFields extends Params.Fields.StringNotation<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.StrictEqual<TFields, Params.Fields.WildcardNotation>,
+        Attribute.GetNonPopulatableKeys<TSchemaUID>
+    ],
+    [
+        Utils.Expression.Extends<TFields, Params.Fields.SingleAttribute<TSchemaUID>>,
+        TFields
+    ],
+    [
+        Utils.Expression.Extends<TFields, `${string},${string}`>,
+        Utils.Array.Values<Utils.String.Split<Utils.Cast<TFields, string>, ','>>
+    ]
+]>;
+type ExtractPopulate<TSchemaUID extends Common.UID.Schema, TPopulate extends Params.Populate.Any<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.Or<Utils.Expression.StrictEqual<TPopulate, Params.Populate.Any<TSchemaUID>>, Utils.Expression.IsNever<TPopulate>>,
+        never
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, Params.Populate.StringNotation<TSchemaUID>>,
+        ParseStringPopulate<TSchemaUID, Utils.Cast<TPopulate, Params.Populate.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, Params.Populate.ArrayNotation<TSchemaUID>>,
+        ParseStringPopulate<TSchemaUID, Utils.Cast<Utils.Array.Values<Utils.Cast<TPopulate, Params.Populate.ArrayNotation<TSchemaUID>>>, Params.Populate.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, Params.Populate.ObjectNotation<TSchemaUID>>,
+        ParseStringPopulate<TSchemaUID, Utils.Cast<keyof TPopulate, Params.Populate.StringNotation<TSchemaUID>>>
+    ]
+]>;
+type ParsePopulateDotNotation<TSchemaUID extends Common.UID.Schema, TPopulate extends Params.Populate.StringNotation<TSchemaUID>> = Utils.String.Split<Utils.Cast<TPopulate, string>, '.'>[0];
+type ParseStringPopulate<TSchemaUID extends Common.UID.Schema, TPopulate extends Params.Populate.StringNotation<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.StrictEqual<Params.Populate.WildcardNotation, TPopulate>,
+        Attribute.GetPopulatableKeys<TSchemaUID>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, `${string},${string}`>,
+        ParsePopulateDotNotation<TSchemaUID, Utils.Cast<Utils.Array.Values<Utils.String.Split<Utils.Cast<TPopulate, string>, ','>>, Params.Populate.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, `${string}.${string}`>,
+        ParsePopulateDotNotation<TSchemaUID, TPopulate>
+    ]
+], TPopulate>;
+export {};

package/dist/services/entity-service/types/result.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=result.js.map

package/dist/services/entity-service/types/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../../../src/services/entity-service/types/result.ts"],"names":[],"mappings":""}

package/dist/services/entity-validator/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Entity validator
+ * Module that will validate input data for entity creation or edition
+ */
+import { Schema } from '../../types';
+export interface EntityValidator {
+    validateEntityCreation: (model: Schema.ContentType, data: Record<string, unknown>, options?: {
+        isDraft?: boolean;
+    }) => Promise<Record<string, unknown>>;
+    validateEntityUpdate: (model: Schema.ContentType, data: Record<string, unknown>, options?: {
+        isDraft?: boolean;
+    }) => Promise<Record<string, unknown>>;
+}
+declare const entityValidator: EntityValidator;
+export default entityValidator;