@aeriajs/types 0.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2023 João Santos (joaosan177@gmail.com)
+
+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,6 @@
+# `@aeriajs/types`
+
+## Introduction
+
+This package exports types used by `@aeriajs/*` packages.
+Many types had to be put separately from their origin packages in order to build Aeria.

package/dist/accessControl.d.ts

@@ -0,0 +1,30 @@
+import type { Collection } from '.';
+export declare enum ACErrors {
+    AuthorizationError = "AUTHORIZATION_ERROR",
+    AuthenticationError = "AUTHENTICATION_ERROR",
+    ImmutabilityIncorrectChild = "IMMUTABILITY_INCORRECT_CHILD",
+    ImmutabilityParentNotFound = "IMMUTABILITY_PARENT_NOT_FOUND",
+    ImmutabilityTargetImmutable = "IMMUTABILITY_TARGET_IMMUTABLE",
+    OwnershipError = "OWNERSHIP_ERROR",
+    ResourceNotFound = "RESOURCE_NOT_FOUND",
+    AssetNotFound = "ASSET_NOT_FOUND",
+    FunctionNotFound = "FUNCTION_NOT_FOUND",
+    InvalidLimit = "INVALID_LIMIT"
+}
+export type Role<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection> = any> = {
+    inherit?: readonly (keyof TAccessControl['roles'])[];
+    grantEverything?: boolean;
+    grant?: readonly (keyof TCollection['functions'])[];
+    forbid?: readonly (keyof TCollection['functions'])[];
+};
+export type Roles<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection> = any> = Record<string, Role<TCollection, TAccessControl>>;
+export type InternalAccessControl<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection, TAccessControl> = any> = {
+    roles?: Roles<TCollection, TAccessControl>;
+    availableRoles?: keyof TAccessControl['roles'];
+    parent?: TAccessControl['roles'];
+};
+export type AccessControl<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection, TAccessControl> = any> = InternalAccessControl<TCollection, TAccessControl>;
+export type ACProfile = {
+    readonly roles?: string[];
+    readonly allowed_functions?: string[];
+};

package/dist/accessControl.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACErrors = void 0;
+var ACErrors;
+(function (ACErrors) {
+    ACErrors["AuthorizationError"] = "AUTHORIZATION_ERROR";
+    ACErrors["AuthenticationError"] = "AUTHENTICATION_ERROR";
+    ACErrors["ImmutabilityIncorrectChild"] = "IMMUTABILITY_INCORRECT_CHILD";
+    ACErrors["ImmutabilityParentNotFound"] = "IMMUTABILITY_PARENT_NOT_FOUND";
+    ACErrors["ImmutabilityTargetImmutable"] = "IMMUTABILITY_TARGET_IMMUTABLE";
+    ACErrors["OwnershipError"] = "OWNERSHIP_ERROR";
+    ACErrors["ResourceNotFound"] = "RESOURCE_NOT_FOUND";
+    ACErrors["AssetNotFound"] = "ASSET_NOT_FOUND";
+    ACErrors["FunctionNotFound"] = "FUNCTION_NOT_FOUND";
+    ACErrors["InvalidLimit"] = "INVALID_LIMIT";
+})(ACErrors || (exports.ACErrors = ACErrors = {}));

package/dist/accessControl.mjs

@@ -0,0 +1,13 @@
+export var ACErrors;
+(function(ACErrors) {
+    ACErrors["AuthorizationError"] = "AUTHORIZATION_ERROR";
+    ACErrors["AuthenticationError"] = "AUTHENTICATION_ERROR";
+    ACErrors["ImmutabilityIncorrectChild"] = "IMMUTABILITY_INCORRECT_CHILD";
+    ACErrors["ImmutabilityParentNotFound"] = "IMMUTABILITY_PARENT_NOT_FOUND";
+    ACErrors["ImmutabilityTargetImmutable"] = "IMMUTABILITY_TARGET_IMMUTABLE";
+    ACErrors["OwnershipError"] = "OWNERSHIP_ERROR";
+    ACErrors["ResourceNotFound"] = "RESOURCE_NOT_FOUND";
+    ACErrors["AssetNotFound"] = "ASSET_NOT_FOUND";
+    ACErrors["FunctionNotFound"] = "FUNCTION_NOT_FOUND";
+    ACErrors["InvalidLimit"] = "INVALID_LIMIT";
+})(ACErrors || (ACErrors = {}));

package/dist/api.d.ts

@@ -0,0 +1,24 @@
+import type { ObjectId, Context, Description, SecurityPolicy, AccessControl, PackReferences } from '.';
+export type Collection<TCollection extends Collection = any> = {
+    description: Description;
+    item?: any;
+    security?: SecurityPolicy;
+    accessControl?: AccessControl<TCollection>;
+    functions?: Record<string, (payload: any, context: Context, ...args: any[]) => any>;
+};
+export type AssetType = keyof Collection;
+export type FunctionPath = `${string}@${string}`;
+export type UserACProfile = {
+    readonly roles: string[];
+    readonly allowed_functions?: string[];
+};
+export type DecodedToken = {
+    authenticated: true;
+    sub: ObjectId;
+    roles: string[];
+    userinfo: PackReferences<Collections['user']['item']>;
+    allowed_functions?: FunctionPath[];
+} | {
+    authenticated: false;
+    sub: null;
+};

package/dist/api.js

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

package/dist/api.mjs

@@ -0,0 +1 @@
+export { };

package/dist/condition.d.ts

@@ -0,0 +1,22 @@
+import type { JsonSchema, PropertiesWithId } from './property';
+export type FinalOperator = 'equal' | 'in' | 'gt' | 'lt' | 'gte' | 'lte';
+export type FinalCondition<TSchema extends JsonSchema = any> = {
+    operator: FinalOperator;
+    term1: PropertiesWithId<TSchema>;
+    term2: any;
+    else?: any;
+};
+export type TruthyCondition<TSchema extends JsonSchema = any> = {
+    operator: 'truthy';
+    term1: PropertiesWithId<TSchema>;
+};
+export type OrCondition<TSchema extends JsonSchema = any> = {
+    or: readonly Condition<TSchema>[];
+};
+export type AndCondition<TSchema extends JsonSchema = any> = {
+    and: readonly Condition<TSchema>[];
+};
+export type NotCondition<TSchema extends JsonSchema = any> = {
+    not: Condition<TSchema>;
+};
+export type Condition<TSchema extends JsonSchema = any> = FinalCondition<TSchema> | TruthyCondition<TSchema> | AndCondition<TSchema> | OrCondition<TSchema> | NotCondition<TSchema>;

package/dist/condition.js

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

package/dist/condition.mjs

@@ -0,0 +1 @@
+export { };

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from './context';
+export type ApiConfig = {
+    secret?: string;
+    apiUrl?: string;
+    port?: number;
+    paginationLimit?: number;
+    database?: {
+        mongodbUrl?: string;
+        noDatabase?: boolean;
+    };
+    storage?: {
+        fs?: string;
+        tempFs?: string;
+    };
+    defaultUser?: {
+        username: string;
+        password: string;
+    };
+    allowSignup?: boolean;
+    signupDefaults?: Partial<{
+        roles: string[];
+        active: boolean;
+    }>;
+    logSuccessfulAuthentications?: boolean;
+    tokenUserProperties?: string[];
+    errorHandler?: <TError extends Error>(context: Context, error: TError) => any | Promise<any>;
+};

package/dist/config.js

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

package/dist/config.mjs

@@ -0,0 +1 @@
+export { };

package/dist/context.d.ts

@@ -0,0 +1,42 @@
+import type { Collection as MongoCollection } from 'mongodb';
+import type { GenericRequest, GenericResponse } from './http';
+import type { Description, PackReferences, SchemaWithId, FunctionPath, DecodedToken, ApiConfig, CollectionDocument, CollectionFunctions } from '.';
+export type CollectionModel<TDescription extends Description> = MongoCollection<Omit<PackReferences<SchemaWithId<TDescription>>, '_id'>>;
+type OmitContextParameter<TFunction> = TFunction extends (payload: infer Payload, context: Context, ...args: infer Rest) => infer Return ? (payload: Payload, ...args: Rest) => Return : never;
+type RestParameters<TFunction> = TFunction extends (payload: any, context: Context, ...args: infer Rest) => any ? Rest : never;
+type UnionFunctions<TFunctions, TSchema extends CollectionDocument<any>> = {
+    [P in keyof TFunctions]: P extends keyof CollectionFunctions<any> ? CollectionFunctions<TSchema>[P] extends infer CollFunction ? CollFunction extends (...args: any[]) => any ? Extract<undefined, Parameters<CollFunction>[0]> extends never ? (payload: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : (payload?: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : never : never : OmitContextParameter<TFunctions[P]>;
+};
+export type IndepthCollection<TCollection> = TCollection extends {
+    description: infer InferredDescription;
+    functions: infer CollFunctions;
+} ? Omit<TCollection, 'functions'> & {
+    functions: UnionFunctions<CollFunctions, SchemaWithId<InferredDescription>>;
+    originalFunctions: CollFunctions;
+    model: InferredDescription extends Description ? CollectionModel<InferredDescription> : never;
+} : TCollection;
+export type IndepthCollections = {
+    [P in keyof Collections]: IndepthCollection<Collections[P]>;
+};
+export type ContextOptions<TContext> = {
+    config?: ApiConfig;
+    parentContext?: TContext;
+    collectionName?: string;
+    token?: DecodedToken;
+};
+export type Context<TDescription extends Description = any, TFunctions = any> = {
+    description: TDescription;
+    collection: TDescription['$id'] extends keyof Collections ? IndepthCollection<{
+        description: TDescription;
+        functions: TFunctions;
+    }> : TDescription;
+    collections: IndepthCollections;
+    functionPath: FunctionPath;
+    token: DecodedToken;
+    collectionName?: (keyof Collections & string) | string;
+    request: GenericRequest;
+    response: GenericResponse;
+    log: (message: string, details?: any) => Promise<any>;
+    config: ApiConfig;
+};
+export {};

package/dist/context.js

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

package/dist/context.mjs

@@ -0,0 +1 @@
+export { };

package/dist/description.d.ts

@@ -0,0 +1,107 @@
+import type { IconStyle, PhosphorIcon } from '@phosphor-icons/core';
+import type { JsonSchema, PropertiesWithId } from './property';
+import type { Condition } from './condition';
+export type CollectionPresets = 'crud' | 'duplicate' | 'remove' | 'removeAll' | 'owned' | 'timestamped' | 'view';
+export type Icon = PhosphorIcon['name'] | `${IconStyle}:${PhosphorIcon['name']}`;
+export type CollectionAction<TDescription extends Description> = Readonly<{
+    name: string;
+    icon?: Icon;
+    ask?: boolean;
+    selection?: boolean;
+    effect?: string;
+    button?: boolean;
+    translate?: boolean;
+    setItem?: boolean;
+    fetchItem?: boolean;
+    clearItem?: boolean;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    requires?: readonly PropertiesWithId<TDescription>[];
+}>;
+export type CollectionActions<TDescription extends Description> = Record<string, null | CollectionAction<TDescription>>;
+export type FormLayout<TDescription extends Description> = {
+    fields?: Partial<Record<PropertiesWithId<TDescription>, FormLayoutField<TDescription>>>;
+};
+export type FormLayoutField<TDescription extends Description> = {
+    span?: number;
+    verticalSpacing?: number;
+    separator?: true | 'top' | 'bottom';
+    if?: Condition<TDescription>;
+    component?: {
+        name: string;
+        props?: Record<string, any>;
+    };
+};
+export type TableLayout<TDescription extends Description> = {
+    actions: Partial<Record<keyof TDescription['individualActions'], {
+        button?: boolean | Condition<TDescription>;
+        if?: Condition<TDescription>;
+    }>>;
+};
+export type FiltersPreset<TDescription extends Description> = {
+    name?: string;
+    icon?: Icon;
+    filters?: Partial<Record<PropertiesWithId<TDescription> | `$${string}`, any>>;
+    table?: readonly PropertiesWithId<TDescription>[];
+    badgeFunction?: string;
+    default?: boolean;
+};
+export type CollectionOptions<TDescription extends Description> = {
+    queryPreset?: {
+        filters?: Partial<Record<PropertiesWithId<TDescription> | `$${string}`, any>>;
+        sort?: Partial<Record<PropertiesWithId<TDescription>, any>>;
+    };
+};
+export type LayoutName = 'tabular' | 'grid' | 'list';
+export type LayoutOptions<TDescription extends Description = any> = {
+    picture?: PropertiesWithId<TDescription>;
+    title?: PropertiesWithId<TDescription>;
+    badge?: PropertiesWithId<TDescription>;
+    information?: PropertiesWithId<TDescription>;
+    active?: PropertiesWithId<TDescription>;
+    translateBadge?: boolean;
+};
+export type Layout<TDescription extends Description = any> = {
+    name: LayoutName;
+    options?: LayoutOptions<TDescription>;
+};
+export type SearchOptions<TDescription extends Description> = {
+    placeholder?: string;
+    indexes: readonly (keyof TDescription['properties'])[];
+};
+export type Description<TDescription extends Description = any> = JsonSchema<TDescription> & {
+    title?: string;
+    categories?: string[];
+    system?: boolean;
+    inline?: boolean;
+    preferred?: Record<string, Partial<TDescription | Description>>;
+    icon?: Icon;
+    options?: CollectionOptions<TDescription>;
+    indexes?: ReadonlyArray<string>;
+    defaults?: Record<string, any>;
+    owned?: boolean | 'always';
+    temporary?: {
+        index: keyof TDescription['properties'];
+        expireAfterSeconds: number;
+    };
+    timestamps?: false;
+    immutable?: boolean | ReadonlyArray<string>;
+    route?: ReadonlyArray<string>;
+    presets?: ReadonlyArray<CollectionPresets>;
+    table?: ReadonlyArray<PropertiesWithId<TDescription>>;
+    tableMeta?: ReadonlyArray<PropertiesWithId<TDescription>>;
+    filtersPresets?: Record<string, FiltersPreset<TDescription>>;
+    freshItem?: Partial<Record<PropertiesWithId<TDescription>, any>>;
+    form?: ReadonlyArray<PropertiesWithId<TDescription>> | Record<PropertiesWithId<TDescription>, string[]>;
+    writable?: ReadonlyArray<PropertiesWithId<TDescription>>;
+    filters?: ReadonlyArray<PropertiesWithId<TDescription> | {
+        property: PropertiesWithId<TDescription>;
+        default: string;
+    }>;
+    layout?: Layout<TDescription>;
+    formLayout?: Partial<FormLayout<TDescription>>;
+    tableLayout?: Partial<TableLayout<TDescription>>;
+    actions?: CollectionActions<TDescription>;
+    individualActions?: CollectionActions<TDescription>;
+    search?: SearchOptions<TDescription>;
+};

package/dist/description.js

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

package/dist/description.mjs

@@ -0,0 +1 @@
+export { };

package/dist/either.d.ts

@@ -0,0 +1,9 @@
+export type Left<T> = {
+    readonly _tag: 'Left';
+    readonly value: T;
+};
+export type Right<T> = {
+    readonly _tag: 'Right';
+    readonly value: T;
+};
+export type Either<L, R> = Left<L> | Right<R>;

package/dist/either.js

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

package/dist/either.mjs

@@ -0,0 +1 @@
+export { };

package/dist/functions.d.ts

@@ -0,0 +1,55 @@
+import type { FilterOperators, UpdateFilter, WithId, OptionalId, ObjectId } from 'mongodb';
+import type { PackReferences, Either, ValidationError } from '.';
+export type UploadAuxProps = {
+    parentId: string;
+    propertyName: string;
+};
+export type Filters<TDocument> = FilterOperators<TDocument>;
+export type What<TDocument> = Omit<UpdateFilter<TDocument>, keyof TDocument> & {
+    [P in keyof TDocument]?: '_id' extends keyof TDocument[P] ? TDocument[P] | string : TDocument[P];
+};
+export type Projection<TDocument extends Record<string, any>> = keyof TDocument | '_id' extends infer DocumentProp ? TDocument extends string ? DocumentProp[] : string[] : never;
+export type QuerySort<TDocument> = Partial<Record<keyof WithId<TDocument>, 1 | -1>>;
+export type CollectionDocument<TDocument> = Pick<TDocument, Extract<keyof TDocument, string>>;
+export type CountPayload<TDocument extends CollectionDocument<OptionalId<any>>> = {
+    filters?: Filters<TDocument>;
+};
+export type GetPayload<TDocument extends CollectionDocument<OptionalId<any>>> = {
+    filters: Filters<TDocument>;
+    project?: Projection<TDocument>;
+    populate?: (keyof TDocument & string)[];
+};
+export type GetAllPayload<TDocument extends CollectionDocument<OptionalId<any>>> = {
+    filters?: Filters<TDocument>;
+    project?: Projection<TDocument>;
+    offset?: number;
+    limit?: number;
+    sort?: QuerySort<TDocument>;
+    populate?: (keyof TDocument & string)[];
+};
+export type InsertPayload<TDocument extends CollectionDocument<any>> = {
+    what: What<PackReferences<TDocument> & {
+        _id?: any;
+    }>;
+    project?: Projection<TDocument>;
+};
+export type RemovePayload<TDocument extends CollectionDocument<OptionalId<any>>> = {
+    filters: Filters<TDocument>;
+};
+export type RemoveAllPayload = {
+    filters: (string | ObjectId)[];
+};
+export type RemoveFilePayload = UploadAuxProps & {
+    filters: {
+        _id: any;
+    };
+};
+export type CollectionFunctions<TDocument extends CollectionDocument<OptionalId<any>>> = {
+    count: (payload: CountPayload<TDocument>) => Promise<number>;
+    get: (payload: GetPayload<TDocument>) => Promise<TDocument | null>;
+    getAll: (payload?: GetAllPayload<TDocument>) => Promise<TDocument[]>;
+    insert: (payload: InsertPayload<TDocument>) => Promise<Either<ValidationError, TDocument>>;
+    remove: (payload: RemovePayload<TDocument>) => Promise<TDocument>;
+    removeAll: (payload: RemoveAllPayload) => Promise<any>;
+    removeFile: (payload: RemoveFilePayload) => Promise<any>;
+};

package/dist/functions.js

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

package/dist/functions.mjs

@@ -0,0 +1 @@
+export { };

package/dist/http.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import type { ServerResponse, IncomingMessage } from 'http';
+import type { MapSchemaUnion } from './schema';
+export declare const REQUEST_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "PATCH", "TRACE", "SEARCH"];
+export type RequestMethod = (typeof REQUEST_METHODS)[number];
+export type GenericRequest = {
+    url: string;
+    method: RequestMethod;
+    headers: Record<string, any>;
+    body?: string;
+    query: Record<string, any>;
+    payload: Record<string, any>;
+    fragments: string[];
+    nodeRequest: IncomingMessage;
+};
+export type GenericResponse = ServerResponse;
+export type EndpointFunction<TRouteMethod extends RequestMethod, TRouteResponse, TRoutePayload> = (TRoutePayload extends null ? (payload?: any) => Promise<TRouteResponse> : TRoutePayload extends undefined ? () => Promise<TRouteResponse> : (payload: TRoutePayload) => Promise<TRouteResponse>) extends infer Function ? Record<TRouteMethod, Function> : never;
+export type MakeEndpoint<TRoute extends string, TRouteMethod extends RequestMethod, TRouteResponse = any, TRoutePayload = null> = TRoute extends `/${infer RouteTail}` ? MakeEndpoint<RouteTail, TRouteMethod, TRouteResponse, TRoutePayload> : TRoute extends `${infer Route}/${infer RouteTail}` ? Record<Route, MakeEndpoint<RouteTail, TRouteMethod, TRouteResponse, TRoutePayload>> : TRoute extends `(${string}` ? Record<string, EndpointFunction<TRouteMethod, TRouteResponse, TRoutePayload>> : Record<TRoute, EndpointFunction<TRouteMethod, TRouteResponse, TRoutePayload>>;
+type UnwrapResponse<TResponse> = TResponse extends readonly any[] ? TResponse : TResponse[];
+export type InferResponse<TResponse> = MapSchemaUnion<UnwrapResponse<TResponse>> extends infer InferredResponse ? InferredResponse | Promise<InferredResponse> : never;
+export {};

package/dist/http.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST_METHODS = void 0;
+exports.REQUEST_METHODS = [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'OPTIONS',
+    'PATCH',
+    'TRACE',
+    'SEARCH',
+];

package/dist/http.mjs

@@ -0,0 +1,11 @@
+export var REQUEST_METHODS = [
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "PATCH",
+    "TRACE",
+    "SEARCH"
+];

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './accessControl.js';
+export * from './api.js';
+export * from './condition.js';
+export * from './config.js';
+export * from './context.js';
+export * from './description.js';
+export * from './either.js';
+export * from './functions.js';
+export * from './http.js';
+export * from './property.js';
+export * from './schema.js';
+export * from './security.js';
+export * from './validation.js';
+export { ObjectId, } from 'mongodb';
+export type { WithId, OptionalId, } from 'mongodb';

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectId = void 0;
+__exportStar(require("./accessControl.js"), exports);
+__exportStar(require("./api.js"), exports);
+__exportStar(require("./condition.js"), exports);
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./context.js"), exports);
+__exportStar(require("./description.js"), exports);
+__exportStar(require("./either.js"), exports);
+__exportStar(require("./functions.js"), exports);
+__exportStar(require("./http.js"), exports);
+__exportStar(require("./property.js"), exports);
+__exportStar(require("./schema.js"), exports);
+__exportStar(require("./security.js"), exports);
+__exportStar(require("./validation.js"), exports);
+var mongodb_1 = require("mongodb");
+Object.defineProperty(exports, "ObjectId", { enumerable: true, get: function () { return mongodb_1.ObjectId; } });

package/dist/index.mjs

@@ -0,0 +1,14 @@
+export * from "./accessControl.mjs";
+export * from "./api.mjs";
+export * from "./condition.mjs";
+export * from "./config.mjs";
+export * from "./context.mjs";
+export * from "./description.mjs";
+export * from "./either.mjs";
+export * from "./functions.mjs";
+export * from "./http.mjs";
+export * from "./property.mjs";
+export * from "./schema.mjs";
+export * from "./security.mjs";
+export * from "./validation.mjs";
+export { ObjectId } from "mongodb";

package/dist/property.d.ts

@@ -0,0 +1,113 @@
+import type { PhosphorIcon } from '@phosphor-icons/core';
+import type { Condition } from '.';
+export type PropertyArrayElement = 'checkbox' | 'radio' | 'select';
+export type PropertyInputType = 'text' | 'email' | 'password' | 'search' | 'time' | 'month';
+export type PropertyFormat = 'date' | 'date-time';
+export type PropertiesWithId<TSchema extends JsonSchema> = keyof TSchema['properties'] | '_id';
+export type RequiredProperties<TSchema extends JsonSchema> = ReadonlyArray<PropertiesWithId<TSchema>> | Partial<Record<PropertiesWithId<TSchema>, Condition<TSchema> | boolean>>;
+export type JsonSchema<TJsonSchema extends JsonSchema = any> = {
+    $id: string;
+    type?: 'object';
+    required?: RequiredProperties<TJsonSchema>;
+    properties: Record<string, Property>;
+};
+export type NonCircularJsonSchema<TJsonSchema extends NonCircularJsonSchema = any> = Omit<JsonSchema<TJsonSchema>, 'properties'> & {
+    properties: Record<string, NonCircularProperty>;
+};
+export type RefProperty = {
+    $ref: Exclude<keyof Collections, 'file'> & string;
+    indexes?: ReadonlyArray<string>;
+    populate?: ReadonlyArray<string>;
+    select?: ReadonlyArray<string>;
+    inline?: boolean;
+    form?: ReadonlyArray<string>;
+    purge?: boolean;
+    constraints?: Condition;
+};
+export type NonCircularRefProperty = Omit<RefProperty, '$ref'> & {
+    $ref: string;
+};
+export type FileProperty = Omit<RefProperty, '$ref'> & {
+    $ref: 'file';
+    accept?: ReadonlyArray<string>;
+    extensions?: ReadonlyArray<string>;
+};
+export type EnumProperty = {
+    enum: ReadonlyArray<any>;
+    default?: any;
+    element?: PropertyArrayElement;
+};
+export type ArrayProperty = {
+    type: 'array';
+    items: Property;
+    uniqueItems?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    element?: PropertyArrayElement;
+};
+export type FixedObjectProperty = {
+    properties: Record<string, Property>;
+    form?: ReadonlyArray<string>;
+    required?: ReadonlyArray<string>;
+};
+export type VariableObjectProperty = {
+    variable: true;
+} | {
+    additionalProperties: Property;
+};
+export type ObjectProperty = (FixedObjectProperty | VariableObjectProperty) & {
+    type: 'object';
+    default?: any;
+};
+export type StringProperty = {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    format?: PropertyFormat;
+    default?: string | Date;
+    mask?: string | ReadonlyArray<string>;
+    placeholder?: string;
+    element?: 'textarea';
+    inputType?: PropertyInputType;
+};
+export type NumberProperty = {
+    type: 'number' | 'integer';
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    default?: number;
+    placeholder?: string;
+};
+export type BooleanProperty = {
+    type: 'boolean';
+    default?: boolean;
+    element?: 'checkbox';
+};
+export type ArrayOfRefs = Omit<ArrayProperty, 'items'> & {
+    items: RefProperty;
+};
+export type LiteralProperty = {
+    literal: string | number | boolean;
+};
+export type GetterProperty = {
+    getter: (document: any) => any;
+};
+export type MixedProperty = RefProperty | FileProperty | EnumProperty | ArrayProperty | ObjectProperty | StringProperty | NumberProperty | BooleanProperty | LiteralProperty | GetterProperty;
+export type NonCircularMixedProperty = NonCircularRefProperty | FileProperty | EnumProperty | ArrayProperty | ObjectProperty | StringProperty | NumberProperty | BooleanProperty | LiteralProperty | GetterProperty;
+export type PropertyBase = {
+    description?: string;
+    readOnly?: boolean;
+    focus?: boolean;
+    icon?: PhosphorIcon['name'];
+    translate?: boolean;
+    hint?: string;
+    componentProps?: Record<string, any>;
+    noForm?: boolean;
+    noLabel?: boolean;
+    hidden?: boolean;
+    unique?: boolean;
+    isTimestamp?: boolean;
+};
+export type Property = PropertyBase & MixedProperty;
+export type NonCircularProperty = PropertyBase & NonCircularMixedProperty;

package/dist/property.js

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

package/dist/property.mjs

@@ -0,0 +1 @@
+export { };

package/dist/schema.d.ts

@@ -0,0 +1,122 @@
+import type { ObjectId } from 'mongodb';
+type Owned = {
+    owner?: Collections['user']['item'];
+};
+type Timestamped = {
+    updated_at?: Date;
+    created_at?: Date;
+};
+type CaseOwned<TSchema, TType> = TSchema extends {
+    owned: true | string;
+} ? TType & Owned : TType;
+type CaseTimestamped<TSchema, TType> = TSchema extends {
+    timestamps: false;
+} ? TType : TType & Timestamped;
+type TestType<T> = T & Record<string, any>;
+export type InferProperty<T> = T extends TestType<{
+    format: 'date' | 'date-time';
+}> ? Date : T extends TestType<{
+    enum: ReadonlyArray<infer K>;
+}> ? K : T extends TestType<{
+    type: 'string';
+}> ? string : T extends TestType<{
+    type: 'number';
+}> ? number : T extends TestType<{
+    type: 'boolean';
+}> ? boolean : T extends TestType<{
+    properties: any;
+}> ? Schema<T & {
+    timestamps: false;
+}> : T extends TestType<{
+    type: 'object';
+}> ? any : T extends TestType<{
+    literal: infer K;
+}> ? K : T extends TestType<{
+    items: infer K;
+}> ? InferProperty<K>[] : T extends TestType<{
+    getter: (doc: any) => infer K;
+}> ? K : never;
+export type InferSchema<TSchema> = MergeReferences<TSchema> extends infer MappedTypes ? TSchema extends {
+    required: readonly [];
+} ? Partial<MappedTypes> : TSchema extends {
+    required: infer RequiredPropNames;
+} ? RequiredPropNames extends readonly (keyof MappedTypes)[] ? Pick<MappedTypes, RequiredPropNames[number]> extends infer RequiredProps ? RequiredProps & Partial<Exclude<MappedTypes, keyof RequiredProps>> : never : never : MappedTypes : never;
+export type Schema<TSchema> = CaseTimestamped<TSchema, CaseOwned<TSchema, InferSchema<TSchema>>>;
+export type SchemaWithId<TSchema> = Schema<TSchema> & {
+    _id: ObjectId;
+};
+export type MapSchemaUnion<TSchema> = TSchema extends readonly (infer SchemaOption)[] ? SchemaOption extends any ? SchemaOption extends {
+    $ref: infer K;
+} | {
+    items: {
+        $ref: infer K;
+    };
+} ? K extends keyof Collections ? 'items' extends keyof SchemaOption ? Collections[K]['item'][] : Collections[K]['item'] : never : InferProperty<SchemaOption> : never : InferProperty<TSchema>;
+export type ObjectToSchema<TObject, TRequired extends string[] | null = null> = TObject extends readonly [infer K] ? ValueToProperty<[K]> : keyof TObject extends never ? {
+    type: 'object';
+} : {
+    [P in keyof TObject]: TObject[P] extends infer Value ? ValueToProperty<Value> : never;
+} extends infer Properties ? TRequired extends null ? {
+    type: 'object';
+    properties: Properties;
+} : {
+    type: 'object';
+    required: TRequired;
+    properties: Properties;
+} : never;
+export type PackReferences<T> = {
+    [P in keyof T]: PackReferencesAux<T[P]>;
+};
+export type FilterReadonlyProperties<TProperties> = {
+    [P in keyof TProperties as TProperties[P] extends {
+        readOnly: true;
+    } ? P : never]: InferProperty<TProperties[P]>;
+};
+type MapReferences<TSchema> = TSchema extends {
+    properties: infer Properties;
+} ? {
+    -readonly [P in keyof Properties as Properties[P] extends TestType<{
+        $ref: string;
+    }> | TestType<{
+        items: {
+            $ref: string;
+        };
+    }> ? P : never]: Properties[P] extends infer Prop ? Prop extends TestType<{
+        $ref: infer K;
+    }> ? K extends keyof Collections ? Collections[K]['item'] : never : Prop extends TestType<{
+        items: TestType<{
+            $ref: infer K;
+        }>;
+    }> ? K extends keyof Collections ? Collections[K]['item'][] : never : never : never;
+} : never;
+type PackReferencesAux<T> = T extends (...args: any[]) => any ? T : T extends {
+    _id: infer Id;
+} ? Id : T extends Record<string, any> ? PackReferences<T> : T extends any[] | readonly any[] ? PackReferencesAux<T[number]>[] : T;
+type CombineProperties<TSchema> = TSchema extends {
+    properties: infer Properties;
+} ? FilterReadonlyProperties<Properties> extends infer ReadonlyProperties ? Readonly<ReadonlyProperties> & {
+    [P in Exclude<keyof Properties, keyof ReadonlyProperties>]: InferProperty<Properties[P]>;
+} : never : never;
+type MergeReferences<TSchema> = CombineProperties<TSchema> extends infer CombinedProperties ? MapReferences<TSchema> extends infer MappedReferences ? MappedReferences & Omit<CombinedProperties, keyof MappedReferences> : never : never;
+type ValueToProperty<TValue> = TValue extends `$${infer Ref}` ? {
+    $ref: Ref;
+} : TValue extends string ? {
+    type: 'string';
+} : TValue extends number ? {
+    type: 'number';
+} : TValue extends boolean ? {
+    type: 'boolean';
+} : TValue extends new () => Date ? {
+    type: 'string';
+    format: 'date';
+} : TValue extends readonly [infer K] ? {
+    type: 'array';
+    items: ValueToProperty<K>;
+} : TValue extends (infer K)[] ? {
+    enum: K;
+} : TValue extends Record<string, any> ? keyof TValue extends never ? {
+    type: 'object';
+} : {
+    type: 'object';
+} & ObjectToSchema<TValue> : never;
+export {};

package/dist/schema.js

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

package/dist/schema.mjs

@@ -0,0 +1 @@
+export { };

package/dist/security.d.ts

@@ -0,0 +1,10 @@
+export type RateLimitingParams = {
+    limit?: number;
+    scale?: number;
+    increment?: number;
+};
+export type SecurityPolicy = {
+    allowQueryOperators?: string[];
+    rateLimiting?: Record<string, RateLimitingParams>;
+    accessControl?: any;
+};

package/dist/security.js

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

package/dist/security.mjs

@@ -0,0 +1 @@
+export { };

package/dist/validation.d.ts

@@ -0,0 +1,26 @@
+export declare enum ValidationErrorCodes {
+    InvalidProperties = "INVALID_PROPERTIES",
+    MissingProperties = "MISSING_PROPERTIES",
+    EmptyTarget = "EMPTY_TARGET"
+}
+export type PropertyValidationErrorType = 'missing' | 'extraneous' | 'unmatching' | 'extraneous_element' | 'numeric_constraint';
+export type PropertyValidationError = {
+    type: PropertyValidationErrorType;
+    index?: number;
+    details: {
+        expected: any;
+        got: string;
+    };
+};
+export type ValidationError = {
+    code: ValidationErrorCodes.InvalidProperties;
+    errors: Record<string, PropertyValidationError | ValidationError>;
+} | {
+    code: ValidationErrorCodes.MissingProperties;
+    errors: Record<string, {
+        type: 'missing';
+    }>;
+} | {
+    code: ValidationErrorCodes.EmptyTarget;
+    errors: {};
+};

package/dist/validation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationErrorCodes = void 0;
+var ValidationErrorCodes;
+(function (ValidationErrorCodes) {
+    ValidationErrorCodes["InvalidProperties"] = "INVALID_PROPERTIES";
+    ValidationErrorCodes["MissingProperties"] = "MISSING_PROPERTIES";
+    ValidationErrorCodes["EmptyTarget"] = "EMPTY_TARGET";
+})(ValidationErrorCodes || (exports.ValidationErrorCodes = ValidationErrorCodes = {}));

package/dist/validation.mjs

@@ -0,0 +1,6 @@
+export var ValidationErrorCodes;
+(function(ValidationErrorCodes) {
+    ValidationErrorCodes["InvalidProperties"] = "INVALID_PROPERTIES";
+    ValidationErrorCodes["MissingProperties"] = "MISSING_PROPERTIES";
+    ValidationErrorCodes["EmptyTarget"] = "EMPTY_TARGET";
+})(ValidationErrorCodes || (ValidationErrorCodes = {}));

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@aeriajs/types",
+  "version": "0.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@phosphor-icons/core": "^2.0.6",
+    "mongodb": "^6.1.0"
+  },
+  "peerDependencies": {
+    "@phosphor-icons/core": "^2.0.6"
+  },
+  "scripts": {
+    "test": "echo skipping",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "build": "pnpm build:cjs && pnpm build:esm",
+    "build:cjs": "tsc",
+    "build:esm": "swc src/* -d dist --strip-leading-paths -C module.type=es6 --out-file-extension=mjs && pnpm build:esm-transform",
+    "build:esm-transform": "pnpm -w esm-transform $PWD/dist"
+  }
+}