@resin/pinejs
Version:
Pine.js is a sophisticated rules-driven API engine that enables you to define rules in a structured subset of English. Those rules are used in order for Pine.js to generate a database schema and the associated [OData](http://www.odata.org/) API. This make
161 lines (160 loc) • 7.17 kB
TypeScript
import type * as Express from 'express';
import type * as Db from '../database-layer/db';
import type { Model } from '../config-loader/config-loader';
import type { AnyObject, RequiredField } from './common-types';
declare global {
namespace Express {
interface Request {
tx?: Db.Tx;
batch?: uriParser.UnparsedRequest[];
}
}
}
import * as Bluebird from 'bluebird';
import { TypedError } from 'typed-error';
declare type LFModel = any[];
import * as AbstractSQLCompiler from '@resin/abstract-sql-compiler';
import * as sbvrTypes from '@resin/sbvr-types';
import { PinejsClientCoreFactory } from 'pinejs-client-core';
import { generateODataMetadata } from '../odata-metadata/odata-metadata-generator';
import * as permissions from './permissions';
export * from './permissions';
import * as uriParser from './uri-parser';
export * from './errors';
import { HookBlueprint, InstantiatedHooks } from './hooks';
export declare let db: Db.Database;
export { sbvrTypes };
export { resolveOdataBind } from './abstract-sql';
export declare type ExecutableModel = RequiredField<Model, 'apiRoot' | 'modelText'> | RequiredField<Model, 'apiRoot' | 'abstractSql'>;
interface CompiledModel {
vocab: string;
se?: string;
lf?: LFModel;
abstractSql: AbstractSQLCompiler.AbstractSqlModel;
sql: AbstractSQLCompiler.SqlModel;
odataMetadata: ReturnType<typeof generateODataMetadata>;
}
export interface HookReq {
user?: User;
apiKey?: ApiKey;
method: string;
url: string;
query: AnyObject;
params: AnyObject;
body: AnyObject;
custom?: AnyObject;
tx?: Db.Tx;
hooks?: InstantiatedHooks<Hooks>;
}
export interface HookArgs {
req: HookReq;
request: HookRequest;
api: PinejsClient;
tx?: Db.Tx;
}
export declare type HookResponse = PromiseLike<any> | null | void;
export declare type HookRequest = uriParser.ODataRequest;
export interface Hooks {
PREPARSE?: (options: HookArgs) => HookResponse;
POSTPARSE?: (options: HookArgs) => HookResponse;
PRERUN?: (options: HookArgs & {
tx: Db.Tx;
}) => HookResponse;
POSTRUN?: (options: HookArgs & {
tx: Db.Tx;
result: any;
}) => HookResponse;
PRERESPOND?: (options: HookArgs & {
tx: Db.Tx;
result: any;
res: any;
data?: any;
}) => HookResponse;
'POSTRUN-ERROR'?: (options: HookArgs & {
error: TypedError | any;
}) => HookResponse;
}
declare type HookBlueprints = {
[key in keyof Hooks]: HookBlueprint[];
};
interface VocabHooks {
[resourceName: string]: HookBlueprints;
}
interface MethodHooks {
[vocab: string]: VocabHooks;
}
declare const apiHooks: {
all: MethodHooks;
GET: MethodHooks;
PUT: MethodHooks;
POST: MethodHooks;
PATCH: MethodHooks;
MERGE: MethodHooks;
DELETE: MethodHooks;
OPTIONS: MethodHooks;
};
export interface Actor {
permissions?: string[];
}
export interface User extends Actor {
id: number;
actor: number;
}
export interface ApiKey extends Actor {
key: string;
actor?: number;
}
export declare const resolveSynonym: (request: Pick<uriParser.ODataRequest, 'abstractSqlModel' | 'resourceName' | 'vocabulary'>) => string;
export declare const resolveNavigationResource: (request: Pick<uriParser.ODataRequest, 'resourceName' | 'vocabulary' | 'abstractSqlModel'>, navigationName: string) => string;
export declare const validateModel: (tx: Db.Tx, modelName: string, request?: uriParser.ODataRequest | undefined) => Bluebird<void>;
export declare const generateLfModel: (seModel: string) => LFModel;
export declare const generateAbstractSqlModel: (lfModel: LFModel) => AbstractSQLCompiler.AbstractSqlModel;
export declare const generateModels: (model: ExecutableModel, targetDatabaseEngine: AbstractSQLCompiler.Engines) => CompiledModel;
export declare const executeModel: (tx: Db.Tx, model: ExecutableModel) => Bluebird<void>;
export declare const executeModels: (arg1: Db.Tx, arg2: ExecutableModel[]) => Bluebird<void>;
declare type HookMethod = keyof typeof apiHooks;
export declare const deleteModel: (arg1: string) => Bluebird<void>;
export declare const getID: (vocab: string, request: uriParser.ODataRequest) => string | number | boolean | Date | AbstractSQLCompiler.DateNode | AbstractSQLCompiler.BooleanNode | AbstractSQLCompiler.InNode | AbstractSQLCompiler.AndNode | AbstractSQLCompiler.OrNode | AbstractSQLCompiler.BindNode | AbstractSQLCompiler.CastNode | AbstractSQLCompiler.CoalesceNode | AbstractSQLCompiler.NumberNode | AbstractSQLCompiler.ConcatenateNode | AbstractSQLCompiler.DurationNode | AbstractSQLCompiler.SelectQueryNode | AbstractSQLCompiler.SelectNode | AbstractSQLCompiler.ValuesNode | AbstractSQLCompiler.AbstractSqlType[] | {
negative?: boolean | undefined;
day?: number | undefined;
hour?: number | undefined;
minute?: number | undefined;
second?: number | undefined;
} | AbstractSQLCompiler.FromNode | AbstractSQLCompiler.InnerJoinNode | AbstractSQLCompiler.LeftJoinNode | AbstractSQLCompiler.RightJoinNode | AbstractSQLCompiler.FullJoinNode | AbstractSQLCompiler.CrossJoinNode | AbstractSQLCompiler.GroupByNode | AbstractSQLCompiler.UnionQueryNode | undefined;
export declare const runRule: (arg1: string, arg2: string) => Bluebird<PinejsClientCoreFactory.AnyObject>;
export declare type Passthrough = AnyObject & {
req?: {
user?: User;
};
tx?: Db.Tx;
};
declare const PinejsClient_base: typeof PinejsClientCoreFactory.PinejsClientCore;
export declare class PinejsClient extends PinejsClient_base<PinejsClient, Bluebird<{}>, Bluebird<PinejsClientCoreFactory.PromiseResultTypes>> {
passthrough: Passthrough;
_request({ method, url, body, tx, req, custom, }: {
method: string;
url: string;
body?: AnyObject;
tx?: Db.Tx;
req?: permissions.PermissionReq;
custom?: AnyObject;
}): Bluebird<PinejsClientCoreFactory.PromiseResultTypes>;
}
export declare type LoggingClient = PinejsClient & {
logger: Console;
};
export declare const api: {
[vocab: string]: LoggingClient;
};
export declare const runURI: (method: string, uri: string, body?: PinejsClientCoreFactory.AnyObject, tx?: Db.Tx | undefined, req?: permissions.PermissionReq | undefined, custom?: PinejsClientCoreFactory.AnyObject | undefined) => Bluebird<PinejsClientCoreFactory.PromiseResultTypes>;
export declare const getAbstractSqlModel: (request: Pick<uriParser.ODataRequest, 'vocabulary' | 'abstractSqlModel'>) => AbstractSQLCompiler.AbstractSqlModel;
export declare const getAffectedIds: (arg1: {
req: HookReq;
request: HookRequest;
tx: Db.Tx;
}) => Bluebird<number[]>;
export declare const handleODataRequest: Express.Handler;
export declare const executeStandardModels: (arg1: Db.Tx) => Bluebird<void>;
export declare const addSideEffectHook: (method: HookMethod, apiRoot: string, resourceName: string, hooks: Hooks) => void;
export declare const addPureHook: (method: HookMethod, apiRoot: string, resourceName: string, hooks: Hooks) => void;
export declare const setup: (arg1: Express.Application, arg2: Db.Database) => Bluebird<void>;