@strapi/types 0.0.0 → 4.15.0-alpha.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present Strapi Solutions SAS
+
+Portions of the Strapi software are licensed as follows:
+
+* All software that resides under an "ee/" directory (the “EE Software”), if that directory exists, is licensed under the license defined in "ee/LICENSE".
+
+* All software outside of the above-mentioned directories or restrictions above is available under the "MIT Expat" license as set forth below.
+
+MIT Expat License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# `@strapi/types`
+
+⚠️ This package is only intended for Strapi internal use and should not be used directly. New versions might break without any prior notice.
+
+Any type you should be using should be imported from `@strapi/strapi` instead.

package/dist/container.d.ts

@@ -0,0 +1,5 @@
+export interface Container {
+    register<T, U extends string>(name: U, resolver: T): Container;
+    get<T = any>(name: string, args?: unknown): T;
+    extend(): Container;
+}

package/dist/index.d.ts

@@ -0,0 +1,138 @@
+import type { Database } from '@strapi/database';
+import type { Logger } from '@strapi/logger';
+import type { Server } from './modules/server';
+import type { EventHub } from './modules/event-hub';
+import type { CronService } from './modules/cron';
+import type { WebhookRunner } from './modules/webhook-runner';
+import type { WebhookStore } from './modules/webhook-store';
+import type { CoreStore } from './modules/core-store';
+import type { EntityValidator } from './modules/entity-validator';
+import type * as EntityService from './modules/entity-service';
+import type { TelemetryService } from './modules/metrics';
+import type { RequestContext } from './modules/request-context';
+import type { Common, Shared, Schema, StrapiDirectories } from './types';
+import type * as CustomFields from './modules/custom-fields';
+import type { Fetch } from './modules/fetch';
+import type { AuthenticationService } from './modules/auth';
+import type { ContentApi } from './modules/content-api';
+import type { SanitizersRegistry } from './modules/sanitizers';
+import type { ValidatorsRegistry } from './modules/validators';
+import type { Container } from './container';
+export type * from './types';
+export { Container, Server, EventHub, CronService, WebhookRunner, WebhookStore, CoreStore, EntityValidator, EntityService, TelemetryService, RequestContext, CustomFields, Fetch, AuthenticationService, ContentApi, SanitizersRegistry, ValidatorsRegistry, };
+declare global {
+    var strapi: LoadedStrapi;
+    namespace NodeJS {
+        interface Global {
+            strapi: LoadedStrapi;
+        }
+    }
+}
+export interface Reloader {
+    isReloading: boolean;
+    isWatching: boolean;
+    (): void;
+}
+export interface StartupLogger {
+    logStats(): void;
+    logFirstStartupMessage(): void;
+    logDefaultStartupMessage(): void;
+    logStartupMessage({ isInitialized }: {
+        isInitialized: boolean;
+    }): void;
+}
+export interface StrapiFS {
+    writeAppFile(optPath: string | string[], data: string): Promise<void>;
+    writePluginFile(plugin: string, optPath: string | string[], data: string): Promise<void>;
+    removeAppFile(optPath: string | string[]): Promise<void>;
+    appendFile(optPath: string | string[], data: string): void;
+}
+export interface ConfigProvider {
+    get<T = unknown>(key: string, defaultVal?: T): T;
+    set(path: string, val: unknown): this;
+    has(path: string): boolean;
+    [key: string]: any;
+}
+export interface Strapi {
+    server: Server;
+    container: Container;
+    log: Logger;
+    fs: StrapiFS;
+    eventHub: EventHub;
+    startupLogger: StartupLogger;
+    cron: CronService;
+    webhookRunner?: WebhookRunner;
+    webhookStore?: WebhookStore;
+    store?: CoreStore;
+    entityValidator?: EntityValidator;
+    entityService?: EntityService.EntityService;
+    telemetry: TelemetryService;
+    requestContext: RequestContext;
+    customFields: CustomFields.CustomFields;
+    fetch: Fetch;
+    dirs: StrapiDirectories;
+    admin?: Common.Module;
+    isLoaded: boolean;
+    db?: Database;
+    app: any;
+    EE?: boolean;
+    components: Shared.Components;
+    reload: Reloader;
+    config: ConfigProvider;
+    services: Record<string, Common.Service>;
+    service(uid: Common.UID.Service): Common.Service;
+    controllers: Record<string, Common.Controller>;
+    controller(uid: Common.UID.Controller): Common.Controller;
+    contentTypes: Shared.ContentTypes;
+    contentType(name: Common.UID.ContentType): Schema.ContentType;
+    policies: Record<string, Common.Policy>;
+    policy(name: string): Common.Policy;
+    middlewares: Record<string, Common.MiddlewareFactory>;
+    middleware(name: string): Common.MiddlewareFactory;
+    plugins: Record<string, Common.Plugin>;
+    plugin(name: string): Common.Plugin;
+    hooks: Record<string, any>;
+    hook(name: string): any;
+    api: Record<string, Common.Module>;
+    auth: AuthenticationService;
+    contentAPI: ContentApi;
+    sanitizers: SanitizersRegistry;
+    validators: ValidatorsRegistry;
+    load(): Promise<Strapi & Required<Strapi>>;
+    start(): Promise<Strapi>;
+    destroy(): Promise<void>;
+    sendStartupTelemetry(): void;
+    openAdmin({ isInitialized }: {
+        isInitialized: boolean;
+    }): void;
+    postListen(): Promise<void>;
+    listen(): Promise<void>;
+    stopWithError(err: unknown, customMessage?: string): never;
+    stop(exitCode?: number): never;
+    loadAdmin(): Promise<void>;
+    loadPlugins(): Promise<void>;
+    loadPolicies(): Promise<void>;
+    loadAPIs(): Promise<void>;
+    loadComponents(): Promise<void>;
+    loadMiddlewares(): Promise<void>;
+    loadApp(): Promise<void>;
+    loadSanitizers(): Promise<void>;
+    loadValidators(): Promise<void>;
+    registerInternalHooks(): void;
+    register(): Promise<Strapi>;
+    bootstrap(): Promise<Strapi>;
+    startWebhooks(): Promise<void>;
+    runLifecyclesFunctions(lifecycleName: 'register' | 'bootstrap' | 'destroy'): Promise<void>;
+    getModel<TUID extends Common.UID.Schema>(uid: TUID): TUID extends Common.UID.ContentType ? Schema.ContentType : Schema.Component;
+    query(uid: Common.UID.Schema): ReturnType<Database['query']>;
+}
+export interface StrapiOptions {
+    appDir?: string;
+    distDir?: string;
+    autoReload?: boolean;
+    serveAdminPanel?: boolean;
+}
+export interface StrapiConstructor {
+    new (options?: StrapiOptions): Strapi;
+}
+export type LoadedStrapi = Required<Strapi>;

package/dist/modules/auth.d.ts

@@ -0,0 +1,24 @@
+import type { ParameterizedContext } from 'koa';
+import type { Common } from '../types';
+interface AuthenticationResponse {
+    authenticated?: boolean;
+    credentials?: unknown;
+    ability?: unknown;
+    error?: Error | null;
+}
+interface AuthenticationInfo {
+    strategy: Strategy;
+    credentials: unknown;
+    ability: unknown;
+}
+interface Strategy {
+    name: string;
+    authenticate: (ctx: ParameterizedContext) => Promise<AuthenticationResponse>;
+    verify?: (auth: AuthenticationInfo, config: Common.RouteConfig['auth']) => Promise<any>;
+}
+export interface AuthenticationService {
+    register: (type: string, strategy: Strategy) => AuthenticationService;
+    authenticate: Common.MiddlewareHandler;
+    verify: (auth: AuthenticationInfo, config?: Common.RouteConfig['auth']) => Promise<any>;
+}
+export {};

package/dist/modules/content-api.d.ts

@@ -0,0 +1,29 @@
+import permissions from '@strapi/permissions';
+import { providerFactory } from '@strapi/utils';
+import { Common } from '../types';
+export interface Condition {
+    name: string;
+    [key: string]: unknown;
+}
+type ConditionProvider = {
+    register: (condition: Condition) => Promise<void>;
+} & ReturnType<typeof providerFactory>;
+type ActionProvider = {
+    register: (action: string, payload: Record<string, unknown>) => Promise<void>;
+} & ReturnType<typeof providerFactory>;
+export interface PermissionUtilities {
+    engine: ReturnType<typeof permissions.engine.new>;
+    providers: {
+        action: ActionProvider;
+        condition: ConditionProvider;
+    };
+    registerActions: () => Promise<void>;
+    getActionsMap: () => Record<string, {
+        controllers: Record<string, string[]>;
+    }>;
+}
+export interface ContentApi {
+    permissions: PermissionUtilities;
+    getRoutesMap: () => Promise<Record<string, Common.Route[]>>;
+}
+export {};

package/dist/modules/core-store.d.ts

@@ -0,0 +1,27 @@
+type SetParams = {
+    key: string;
+    value: unknown;
+    type?: string;
+    environment?: string;
+    name?: string;
+    tag?: string;
+};
+type GetParams = {
+    key: string;
+    type?: string;
+    environment?: string;
+    name?: string;
+    tag?: string;
+};
+type Params = SetParams & GetParams;
+export interface CoreStore {
+    (defaultParams: Partial<Params>): {
+        get(params: Partial<GetParams>): Promise<unknown>;
+        set(params: Partial<SetParams>): Promise<void>;
+        delete(params: Partial<GetParams>): Promise<void>;
+    };
+    get(params: GetParams): Promise<unknown>;
+    set(params: SetParams): Promise<void>;
+    delete(params: GetParams): Promise<void>;
+}
+export {};

package/dist/modules/cron.d.ts

@@ -0,0 +1,26 @@
+import type { Job } from 'node-schedule';
+import type { Strapi } from '..';
+interface JobSpec {
+    job: Job;
+    options: string | number | Date;
+    name: string | null;
+}
+type TaskFn = ({ strapi }: {
+    strapi: Strapi;
+}, ...args: unknown[]) => Promise<unknown>;
+type Task = TaskFn | {
+    task: TaskFn;
+    options: string;
+};
+interface Tasks {
+    [key: string]: Task;
+}
+export interface CronService {
+    add(tasks: Tasks): CronService;
+    remove(name: string): CronService;
+    start(): CronService;
+    stop(): CronService;
+    destroy(): CronService;
+    jobs: JobSpec[];
+}
+export {};

package/dist/modules/custom-fields.d.ts

@@ -0,0 +1,24 @@
+export interface CustomFieldServerOptions {
+    /**
+     * The name of the custom field
+     */
+    name: string;
+    /**
+     * The name of the plugin creating the custom field
+     */
+    plugin?: string;
+    /**
+     * The existing Strapi data type the custom field uses
+     */
+    type: 'biginteger' | 'boolean' | 'date' | 'datetime' | 'decimal' | 'email' | 'enumeration' | 'float' | 'integer' | 'json' | 'password' | 'richtext' | 'string' | 'text' | 'time' | 'uid';
+    /**
+     * Settings for the input size in the Admin UI
+     */
+    inputSize?: {
+        default: 4 | 6 | 8 | 12;
+        isResizable: boolean;
+    };
+}
+export interface CustomFields {
+    register: (customFields: CustomFieldServerOptions[] | CustomFieldServerOptions) => void;
+}

package/dist/modules/entity-service/index.d.ts

@@ -0,0 +1,73 @@
+import type { Attribute, Common, Utils } from '../../types';
+import type { PartialEntity, Entity, Result, PaginatedResult } from './result';
+import type * as Params from './params';
+export type UploadFile = (uid: Common.UID.Schema, entity: Record<string, unknown>, files: Record<string, unknown>) => Promise<void>;
+export * as Params from './params';
+export * from './result';
+export * from './plugin';
+type WrapAction = Omit<keyof EntityService, 'wrapParams' | 'wrapResult' | 'emitEvent'>;
+export interface EntityService {
+    uploadFiles: UploadFile;
+    wrapParams<TResult extends object = object, TContentTypeUID extends Common.UID.ContentType = Common.UID.ContentType, TParams extends object = object>(params?: TParams, options?: {
+        uid: TContentTypeUID;
+        action: WrapAction;
+    }): Promise<TResult> | TResult;
+    wrapResult<TResult = any, TContentTypeUID extends Common.UID.ContentType = Common.UID.ContentType>(result: unknown, options?: {
+        uid: TContentTypeUID;
+        action: WrapAction;
+        [key: string]: unknown;
+    }): Promise<TResult> | TResult;
+    emitEvent<TContentTypeUID extends Common.UID.ContentType>(uid: TContentTypeUID, event: string, entity: Entity<TContentTypeUID>): Promise<void>;
+    findMany<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'fields' | 'filters' | '_q' | 'pagination:offset' | 'sort' | 'populate' | 'publicationState' | 'plugin'>>(uid: TContentTypeUID, params?: TParams): Promise<Utils.Expression.MatchFirst<[
+        [
+            Common.UID.IsCollectionType<TContentTypeUID>,
+            Result<TContentTypeUID, TParams>[]
+        ],
+        [
+            Common.UID.IsSingleType<TContentTypeUID>,
+            Result<TContentTypeUID, TParams> | null
+        ]
+    ], (Result<TContentTypeUID, TParams> | null) | Result<TContentTypeUID, TParams>[]>>;
+    findOne<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'fields' | 'populate'>>(uid: TContentTypeUID, entityId: Params.Attribute.ID, params?: TParams): Promise<Result<TContentTypeUID, TParams> | null>;
+    delete<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'fields' | 'populate'>>(uid: TContentTypeUID, entityId: Params.Attribute.ID, params?: TParams): Promise<Result<TContentTypeUID, TParams> | null>;
+    create<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'data' | 'files' | 'fields' | 'populate'>>(uid: TContentTypeUID, params?: TParams): Promise<Result<TContentTypeUID, TParams>>;
+    update<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'data:partial' | 'files' | 'fields' | 'populate'>>(uid: TContentTypeUID, entityId: Params.Attribute.ID, params?: TParams): Promise<Result<TContentTypeUID, TParams> | null>;
+    findPage<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'fields' | 'populate' | 'pagination' | 'sort' | 'filters' | '_q' | 'publicationState' | 'plugin'>>(uid: TContentTypeUID, params?: TParams): Promise<PaginatedResult<TContentTypeUID, TParams>>;
+    clone<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'data' | 'files' | 'fields' | 'populate'>>(uid: TContentTypeUID, cloneId: Params.Attribute.ID, params?: TParams): Promise<Result<TContentTypeUID, TParams> | null>;
+    /**
+     * @deprecated
+     */
+    deleteMany<TContentTypeUID extends Common.UID.ContentType>(uid: TContentTypeUID, params: Params.Pick<TContentTypeUID, 'filters' | '_q'>): Promise<{
+        count: number;
+    }>;
+    /**
+     * TODO: seems the same as findMany, it's not returning count by default
+     * @deprecated
+     */
+    findWithRelationCounts<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'fields' | 'filters' | '_q' | 'pagination:offset' | 'sort' | 'populate' | 'publicationState' | 'plugin'>>(uid: TContentTypeUID, params?: TParams): Promise<Result<TContentTypeUID, TParams>[]>;
+    /**
+     * @deprecated
+     */
+    findWithRelationCountsPage<TContentTypeUID extends Common.UID.ContentType, TParams extends Params.Pick<TContentTypeUID, 'fields' | 'filters' | '_q' | 'pagination' | 'sort' | 'populate' | 'publicationState' | 'plugin'>>(uid: TContentTypeUID, params?: TParams): Promise<PaginatedResult<TContentTypeUID, TParams>>;
+    count<TContentTypeUID extends Common.UID.ContentType>(uid: TContentTypeUID, params?: Params.Pick<TContentTypeUID, 'filters' | '_q'>): Promise<number>;
+    /**
+     * TODO: Considering making this API public include providing a valid return type
+     * @internal
+     */
+    load<TContentTypeUID extends Common.UID.ContentType, TField extends Attribute.GetPopulatableKeys<TContentTypeUID>>(uid: TContentTypeUID, entity: PartialEntity<TContentTypeUID>, field: Utils.Guard.Never<TField, string>, params?: GetPopulatableFieldParams<TContentTypeUID, TField>): Promise<any>;
+    /**
+     * TODO: Considering making this API public include providing a valid return type
+     * @internal
+     */
+    loadPages<TContentTypeUID extends Common.UID.ContentType, TField extends Attribute.GetPopulatableKeys<TContentTypeUID>>(uid: TContentTypeUID, entity: PartialEntity<TContentTypeUID>, field: Utils.Guard.Never<TField, string>, params?: GetPopulatableFieldParams<TContentTypeUID, TField>, pagination?: Params.Pagination.Any): Promise<any>;
+}
+type GetPopulatableFieldParams<TContentTypeUID extends Common.UID.ContentType, TField extends Attribute.GetPopulatableKeys<TContentTypeUID>> = Utils.Expression.MatchFirst<[
+    [
+        Attribute.HasTarget<TContentTypeUID, TField>,
+        Params.Populate.NestedParams<Attribute.GetTarget<TContentTypeUID, TField>>
+    ],
+    [
+        Attribute.HasMorphTargets<TContentTypeUID, TField>,
+        (Params.Populate.Fragment<Attribute.GetMorphTargets<TContentTypeUID, TField>> | Params.Populate.NestedParams<Common.UID.Schema>)
+    ]
+], Params.Populate.Fragment<Common.UID.Schema> | Params.Populate.NestedParams<Common.UID.Schema>>;

package/dist/modules/entity-service/params/attributes.d.ts

@@ -0,0 +1,74 @@
+import type { Attribute, Common, Utils } from '../../../types';
+export type NonFilterableKind = Extract<Attribute.Kind, 'password' | 'dynamiczone'>;
+export type FilterableKind = Exclude<Attribute.Kind, NonFilterableKind>;
+export type GetNonFilterableKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysBy<Attribute.GetAll<TSchemaUID>, Attribute.OfType<NonFilterableKind>, string>;
+export type GetScalarKeys<TSchemaUID extends Common.UID.Schema> = Exclude<Attribute.GetKeysByType<TSchemaUID, Attribute.NonPopulatableKind>, GetNonFilterableKeys<TSchemaUID>>;
+export type GetNestedKeys<TSchemaUID extends Common.UID.Schema> = Exclude<Attribute.GetKeysWithTarget<TSchemaUID>, GetNonFilterableKeys<TSchemaUID>>;
+export type ID = `${number}` | number;
+export type BooleanValue = boolean | 'true' | 'false' | 't' | 'f' | '1' | '0' | 1 | 0;
+export type NumberValue = string | number;
+export type DateValue = Attribute.DateValue | number;
+export type TimeValue = Attribute.TimeValue | number;
+export type DateTimeValue = Attribute.DateTimeValue | number;
+export type TimeStampValue = Attribute.TimestampValue;
+/**
+ * List of possible values for the scalar attributes
+ * Uses the local GetValue to benefit from the values' overrides
+ */
+export type ScalarValues = GetValue<Attribute.BigInteger | Attribute.Boolean | Attribute.DateTime | Attribute.Date | Attribute.Decimal | Attribute.Email | Attribute.Enumeration<string[]> | Attribute.Float | Attribute.Integer | Attribute.Blocks | Attribute.JSON | Attribute.RichText | Attribute.String | Attribute.Text | Attribute.Time | Attribute.Timestamp | Attribute.UID<Common.UID.Schema>>;
+/**
+ * Attribute.GetValues override with extended values
+ */
+export type GetValues<TSchemaUID extends Common.UID.Schema> = {
+    id?: ID;
+} & OmitRelationWithoutTarget<TSchemaUID, {
+    [TKey in Attribute.GetOptionalKeys<TSchemaUID>]?: GetValue<Attribute.Get<TSchemaUID, TKey>>;
+} & {
+    [TKey in Attribute.GetRequiredKeys<TSchemaUID>]-?: GetValue<Attribute.Get<TSchemaUID, TKey>>;
+}>;
+export type OmitRelationWithoutTarget<TSchemaUID extends Common.UID.Schema, TValue> = Omit<TValue, Exclude<Attribute.GetKeysByType<TSchemaUID, 'relation'>, Attribute.GetKeysWithTarget<TSchemaUID>>>;
+/**
+ * Attribute.GetValue override with extended values
+ *
+ * Fallback to unknown if never is found
+ */
+export type GetValue<TAttribute extends Attribute.Attribute> = Utils.Expression.If<Utils.Expression.IsNotNever<TAttribute>, Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.OfType<'relation'>>,
+        TAttribute extends Attribute.Relation<infer _TOrigin, infer TRelationKind, infer TTarget> ? Utils.Expression.If<Utils.Expression.IsNotNever<TTarget>, Attribute.RelationPluralityModifier<TRelationKind, ID>> : never
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.OfType<'dynamiczone'>>,
+        TAttribute extends Attribute.DynamicZone<infer TComponentsUIDs> ? Array<Utils.Array.Values<TComponentsUIDs> extends infer TComponentUID ? TComponentUID extends Common.UID.Component ? GetValues<TComponentUID> & {
+            __component: TComponentUID;
+        } : never : never> : never
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.OfType<'component'>>,
+        TAttribute extends Attribute.Component<infer TComponentUID, infer TRepeatable> ? TComponentUID extends Common.UID.Component ? GetValues<TComponentUID> extends infer TValues ? Utils.Expression.If<TRepeatable, TValues[], TValues> : never : never : never
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.Boolean>,
+        BooleanValue
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.Integer | Attribute.BigInteger | Attribute.Float | Attribute.Decimal>,
+        NumberValue
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.Time>,
+        TimeValue
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.Date>,
+        DateValue
+    ],
+    [
+        Utils.Expression.Extends<TAttribute, Attribute.Timestamp | Attribute.DateTime>,
+        DateTimeValue
+    ],
+    [
+        Utils.Expression.True,
+        Attribute.GetValue<TAttribute, unknown>
+    ]
+], unknown>, unknown>;

package/dist/modules/entity-service/params/data.d.ts

@@ -0,0 +1,3 @@
+import type { Common } from '../../../types';
+import type * as AttributeUtils from './attributes';
+export type Input<TSchemaUID extends Common.UID.Schema> = AttributeUtils.GetValues<TSchemaUID>;

package/dist/modules/entity-service/params/fields.d.ts

@@ -0,0 +1,58 @@
+import type { Attribute, Common, Utils } from '../../../types';
+/**
+ * Wildcard notation for the fields.
+ *
+ * When used, it represents every non-populatable field from the given schema
+ */
+export type WildcardNotation = '*';
+/**
+ * Single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'description'; // ✅
+ * type C = 'populatableField'; // ❌
+ * type D = '<random_string>'; // ❌
+ */
+export type SingleAttribute<TSchemaUID extends Common.UID.Schema> = 'id' | Utils.Guard.Never<Attribute.GetNonPopulatableKeys<TSchemaUID>, string>;
+/**
+ * Union of all possible string representation for fields
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'title,description'; // ✅
+ * type C = 'id'; // ✅
+ * type D = '*'; // ✅
+ * type E = 'populatableField'; // ❌
+ * type F = '<random_string>'; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> = WildcardNotation | SingleAttribute<TSchemaUID> | `${string},${string}`;
+/**
+ * Array notation for fields
+ *
+ * @example
+ * type A = ['title']; // ✅
+ * type B = ['title', 'description']; // ✅
+ * type C = ['id']; // ✅
+ * type E = ['*']; // ❌
+ * type F = ['populatableField']; // ❌
+ * type G = ['<random_string>']; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Exclude<StringNotation<TSchemaUID>, WildcardNotation>[];
+/**
+ * Represents any notation for a sort (string, array, object)
+ *
+ * @example
+ * type A = '*'; // ✅
+ * type B = 'id'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description'; // ✅
+ * type E = ['title', 'description']; // ✅
+ * type F = [id, 'title,description']; // ✅
+ * type G = ['*']; // ❌
+ * type H = ['populatableField']; // ❌
+ * type I = ['<random_string>']; // ❌
+ * type J = 'populatableField'; // ❌
+ * type K = '<random_string>'; // ❌
+ */
+export type Any<TSchemaUID extends Common.UID.Schema> = StringNotation<TSchemaUID> | ArrayNotation<TSchemaUID>;

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

@@ -0,0 +1,53 @@
+import type { Attribute, Common, Utils } from '../../../../types';
+import type * as Operator from './operators';
+import type * as AttributeUtils from '../attributes';
+import type * as Params from '..';
+export { Operator };
+type IDKey = 'id';
+/**
+ * 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 IDKey | Attribute.GetKeys<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.StrictEqual<TAttributeName, IDKey>,
+        Params.Attribute.ID
+    ],
+    [
+        Utils.Expression.IsNotNever<TAttributeName>,
+        AttributeUtils.GetValue<Attribute.Get<TSchemaUID, Exclude<TAttributeName, IDKey>>>
+    ]
+], 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 IDKey | TScalarKeys]?: AttributeCondition<TSchemaUID, TIter>;
+} & {
+    [TIter in TNestedKeys]?: NestedAttributeCondition<TSchemaUID, TIter>;
+}, {
+    [TKey in string]?: AttributeCondition<TSchemaUID, never> | NestedAttributeCondition<TSchemaUID, never>;
+}> : never);
+export type Any<TSchemaUID extends Common.UID.Schema> = ObjectNotation<TSchemaUID>;

package/dist/modules/entity-service/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' | '$nei' | '$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;