@teamkeel/functions-runtime 0.219.0

package/dist/index.d.ts

@@ -0,0 +1,286 @@
+declare module '@teamkeel/functions-runtime/constraints' {
+  export type StringConstraint = string | {
+      startsWith?: string;
+      endsWith?: string;
+      oneOf?: string[];
+      contains?: string;
+      notEquals?: string;
+      equals?: string;
+  };
+  export type NumberConstraint = number | {
+      greaterThan?: number;
+      greaterThanOrEquals?: number;
+      lessThan?: number;
+      lessThanOrEquals?: number;
+      equals?: number;
+      notEquals?: number;
+  };
+  export type BooleanConstraint = boolean | {
+      equals?: boolean;
+      notEquals?: boolean;
+  };
+  export type DateConstraint = Date | {
+      equals?: Date;
+      before?: Date;
+      onOrBefore?: Date;
+      after?: Date;
+      onOrAfter?: Date;
+  };
+  export type EnumConstraint = StringConstraint;
+
+}
+declare module '@teamkeel/functions-runtime/db/query' {
+  export type SqlQueryParts = SqlQueryPart[];
+  export type SqlQueryPart = RawSql | SqlInput;
+  export type RawSql = {
+      type: "sql";
+      value: string;
+  };
+  export type SqlInput = {
+      type: "input";
+      value: any;
+  };
+  export function rawSql(sql: string): SqlQueryPart;
+  export function sqlIdentifier(identifier: string, identifierField?: string | null): SqlQueryPart;
+  export function sqlInput(input: any): SqlQueryPart;
+  export function sqlInputArray(inputs: any[]): SqlQueryPart[];
+  export function sqlAddSeparator(parts: SqlQueryPart[], separator: SqlQueryPart): SqlQueryPart[];
+  export function sqlAddSeparatorAndFlatten(parts: SqlQueryPart[][], separator: SqlQueryPart): SqlQueryPart[];
+
+}
+declare module '@teamkeel/functions-runtime/db/resolver' {
+  import { SqlQueryParts } from "@teamkeel/functions-runtime/db/query";
+  export interface QueryResolver {
+      runQuery(query: SqlQueryParts): Promise<QueryResult>;
+  }
+  export interface QueryResult {
+      rows: QueryResultRow[];
+  }
+  export interface QueryResultRow {
+      [column: string]: any;
+  }
+  export function queryResolverFromEnv(env: Record<string, string | undefined>): QueryResolver;
+  export class PgQueryResolver implements QueryResolver {
+      private readonly pool;
+      constructor(config: {
+          connectionString: string;
+      });
+      runQuery(query: SqlQueryParts): Promise<QueryResult>;
+      private toQuery;
+  }
+  export class AwsRdsDataClientQueryResolver implements QueryResolver {
+      private readonly client;
+      private readonly dbClusterResourceArn;
+      private readonly dbCredentialsSecretArn;
+      private readonly dbName;
+      constructor(config: {
+          region: string;
+          dbClusterResourceArn: string;
+          dbCredentialsSecretArn: string;
+          dbName: string;
+      });
+      runQuery(query: SqlQueryParts): Promise<QueryResult>;
+      private toQuery;
+      private toDataApiFormat;
+  }
+
+}
+declare module '@teamkeel/functions-runtime/fetch/index' {
+  import { RequestInit } from "node-fetch";
+  type RequestOpts = Omit<RequestInit, "referrer">;
+  const _default: (uri: string, opts: RequestOpts) => Promise<import("node-fetch").Response>;
+  export default _default;
+
+}
+declare module '@teamkeel/functions-runtime/handler/index' {
+  import { Config } from "@teamkeel/functions-runtime/types";
+  const startRuntimeServer: ({ functions, api }: Config) => void;
+  export default startRuntimeServer;
+
+}
+declare module '@teamkeel/functions-runtime/index' {
+  import Query, { ChainableQuery } from "@teamkeel/functions-runtime/query";
+  import * as QueryConstraints from "@teamkeel/functions-runtime/constraints";
+  import Logger, { ConsoleTransport, Level as LogLevel } from "@teamkeel/functions-runtime/logger/index";
+  import { Identity } from "@teamkeel/functions-runtime/types";
+  export * from "@teamkeel/functions-runtime/returnTypes";
+  export * from "@teamkeel/functions-runtime/db/resolver";
+  import { queryResolverFromEnv } from "@teamkeel/functions-runtime/db/resolver";
+  export { Query, ChainableQuery, QueryConstraints, Logger, ConsoleTransport, LogLevel, Identity, queryResolverFromEnv, };
+
+}
+declare module '@teamkeel/functions-runtime/logger/index' {
+  export enum Level {
+      Info = "info",
+      Error = "error",
+      Debug = "debug",
+      Warn = "warn",
+      Success = "success"
+  }
+  export interface LoggerOptions {
+      transport?: Transport;
+      colorize?: boolean;
+      timestamps?: boolean;
+  }
+  export interface Transport {
+      log: (msg: Msg, level: Level, options: LoggerOptions) => void;
+  }
+  export class ConsoleTransport implements Transport {
+      log: (msg: Msg, level: Level, options: LoggerOptions) => void;
+  }
+  type Msg = any;
+  export default class Logger {
+      private readonly options;
+      constructor(opts?: LoggerOptions);
+      log: (msg: Msg, level?: Level) => void;
+  }
+  export {};
+
+}
+declare module '@teamkeel/functions-runtime/query' {
+  import { Conditions, ChainedQueryOpts, QueryOpts, Input, OrderClauses } from "@teamkeel/functions-runtime/types";
+  import * as ReturnTypes from "@teamkeel/functions-runtime/returnTypes";
+  export class ChainableQuery<T extends IDer> {
+      private readonly tableName;
+      private readonly conditions;
+      private orderClauses;
+      private readonly queryResolver;
+      private readonly logger;
+      constructor({ tableName, queryResolver, conditions, logger, }: ChainedQueryOpts<T>);
+      orWhere: (conditions: Conditions<T>) => ChainableQuery<T>;
+      all: () => Promise<ReturnTypes.FunctionListResponse<T>>;
+      findOne: () => Promise<ReturnTypes.FunctionGetResponse<T>>;
+      order: (clauses: OrderClauses<T>) => ChainableQuery<T>;
+      private appendConditions;
+      private execute;
+  }
+  interface IDer {
+      id: string;
+  }
+  export default class Query<T extends IDer> {
+      private readonly tableName;
+      private readonly conditions;
+      private readonly queryResolver;
+      private readonly logger;
+      constructor({ tableName, queryResolver, logger }: QueryOpts);
+      create: (inputs: Partial<T>) => Promise<ReturnTypes.FunctionCreateResponse<T>>;
+      where: (conditions: Conditions<T>) => ChainableQuery<T>;
+      delete: (id: string) => Promise<ReturnTypes.FunctionDeleteResponse<T>>;
+      findOne: (conditions: Conditions<T>) => Promise<ReturnTypes.FunctionGetResponse<T>>;
+      update: (id: string, inputs: Input<T>) => Promise<ReturnTypes.FunctionUpdateResponse<T>>;
+      all: () => Promise<ReturnTypes.FunctionListResponse<T>>;
+      private execute;
+  }
+  export {};
+
+}
+declare module '@teamkeel/functions-runtime/queryBuilders/index' {
+  import { Conditions, Constraints, OrderClauses, OrderDirection } from "@teamkeel/functions-runtime/types";
+  import { SqlQueryParts } from "@teamkeel/functions-runtime/db/query";
+  export const buildSelectStatement: <T>(tableName: string, conditions: Partial<{ [K in keyof T]: Constraints<T[K]>; }>[], order?: Partial<Record<keyof T, OrderDirection>>, limit?: number) => SqlQueryParts;
+  export const buildCreateStatement: <T>(tableName: string, inputs: Partial<T>) => SqlQueryParts;
+  export const buildUpdateStatement: <T>(tableName: string, id: string, inputs: Partial<T>) => SqlQueryParts;
+  export const buildDeleteStatement: <T>(tableName: string, id: string) => SqlQueryParts;
+
+}
+declare module '@teamkeel/functions-runtime/returnTypes' {
+  export interface ValidationError {
+      field: string;
+      message: string;
+      code: string;
+  }
+  export interface ExecutionError {
+      message: string;
+      stack: string;
+  }
+  export type FunctionError = ValidationError | ExecutionError;
+  export interface FunctionCreateResponse<T> {
+      object?: T;
+      errors?: FunctionError[];
+  }
+  export interface FunctionGetResponse<T> {
+      object?: T;
+      errors?: FunctionError[];
+  }
+  export interface FunctionDeleteResponse<T> {
+      success: boolean;
+      errors?: FunctionError[];
+  }
+  export interface FunctionListResponse<T> {
+      collection: T[];
+      errors?: FunctionError[];
+  }
+  export interface FunctionUpdateResponse<T> {
+      object?: T;
+      errors?: FunctionError[];
+  }
+  export interface FunctionAuthenticateResponse {
+      identityId?: string;
+      identityCreated: boolean;
+      errors?: FunctionError[];
+  }
+
+}
+declare module '@teamkeel/functions-runtime/staticAnalysis/analyse' {
+  export interface AnalyseOptions {
+      path: string;
+  }
+  const _default: (opts: AnalyseOptions) => Promise<import("@structured-types/api").PropTypes>;
+  export default _default;
+
+}
+declare module '@teamkeel/functions-runtime/staticAnalysis/cli' {
+  export {};
+
+}
+declare module '@teamkeel/functions-runtime/types' {
+  import { StringConstraint, BooleanConstraint, NumberConstraint, DateConstraint, EnumConstraint } from "@teamkeel/functions-runtime/constraints";
+  import { Logger } from "@teamkeel/functions-runtime/index";
+  import { QueryResolver } from "@teamkeel/functions-runtime/db/resolver";
+  export interface QueryOpts {
+      tableName: string;
+      queryResolver: QueryResolver;
+      logger: Logger;
+  }
+  export interface ChainedQueryOpts<T> extends QueryOpts {
+      conditions: Conditions<T>[];
+  }
+  export type Constraints<T> = T extends String ? StringConstraint : T extends Boolean ? BooleanConstraint : T extends Number ? NumberConstraint : T extends Date ? DateConstraint : EnumConstraint;
+  export type Input<T> = Record<keyof T, unknown>;
+  export type Conditions<T> = Partial<{
+      [K in keyof T]: Constraints<T[K]>;
+  }>;
+  export interface BuiltInFields {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+  }
+  export type OrderDirection = "ASC" | "DESC";
+  export type OrderClauses<T> = Partial<Record<keyof T, OrderDirection>>;
+  export interface Identity {
+      id: string;
+      email: string;
+  }
+  export interface CustomFunction {
+      call: any;
+  }
+  export interface Config {
+      functions: Record<string, CustomFunction>;
+      api: unknown;
+  }
+
+}
+declare module '@teamkeel/functions-runtime/util/camelCaser' {
+  const _default: (input: string) => string;
+  export default _default;
+
+}
+declare module '@teamkeel/functions-runtime/util/snakeCaser' {
+  const _default: (input: string) => string;
+  export default _default;
+
+}
+declare module '@teamkeel/functions-runtime' {
+  import main = require('@teamkeel/functions-runtime/index');
+  export = main;
+}