@niledatabase/server 1.0.0 → 2.1.0

package/dist/types.d.ts

@@ -1,19 +1,20 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import 'knex';
-import { ConnectionOptions } from 'tls';
-import stream from 'node:stream';
-import { Knex } from 'knex';
+import { PoolClient, PoolConfig } from 'pg';
 export type Opts = {
     basePath?: string;
     fetch?: typeof fetch;
 };
+export type NilePoolConfig = PoolConfig & {
+    afterCreate?: AfterCreate;
+};
 export type ServerConfig = {
-    database: string;
+    databaseId?: string;
+    user?: string;
+    password?: string;
+    databaseName?: string;
     tenantId?: string | null | undefined;
     userId?: string | null | undefined;
-    workspace: string;
-    db?: Knex.Config;
+    debug?: boolean;
+    db?: NilePoolConfig;
     api?: {
         basePath?: string;
         cookieKey?: string;
@@ -21,58 +22,20 @@ export type ServerConfig = {
     };
 };
 export type InstanceConfig = {
-    database?: string;
+    databaseId: string;
+    user: string;
+    password: string;
     tenantId?: string | null | undefined;
     userId?: string | null | undefined;
-    workspace?: string;
-    db?: Knex.Config;
+    debug?: boolean;
+    db?: NilePoolConfig;
     api?: {
         basePath?: string;
         cookieKey?: string;
         token?: string;
     };
 };
-export type NileDb = Knex & {
+export type NileDb = NilePoolConfig & {
     tenantId?: string;
 };
-export type PgConnectionConfig = {
-    user?: string;
-    database?: string;
-    password?: string | (() => string | Promise<string>);
-    port?: number;
-    host?: string;
-    connectionString?: string;
-    keepAlive?: boolean;
-    stream?: stream.Duplex;
-    statement_timeout?: false | number;
-    parseInputDatesAsUTC?: boolean;
-    ssl?: boolean | ConnectionOptions;
-    query_timeout?: number;
-    keepAliveInitialDelayMillis?: number;
-    idle_in_transaction_session_timeout?: number;
-    application_name?: string;
-    connectionTimeoutMillis?: number;
-    options?: string;
-    expirationChecker?(): boolean;
-};
-export type AfterCreate = (conn: {
-    on: any;
-    query: (query: string, cb: (err: unknown) => void) => void;
-}, done: (err: unknown, conn: unknown) => void) => void;
-export type PoolConfig = {
-    name?: string;
-    afterCreate?: Function;
-    min?: number;
-    max?: number;
-    refreshIdle?: boolean;
-    idleTimeoutMillis?: number;
-    reapIntervalMillis?: number;
-    returnToHead?: boolean;
-    priorityRange?: number;
-    log?: (message: string, logLevel: string) => void;
-    propagateCreateError?: boolean;
-    createRetryIntervalMillis?: number;
-    createTimeoutMillis?: number;
-    destroyTimeoutMillis?: number;
-    acquireTimeoutMillis?: number;
-};
+export type AfterCreate = (conn: PoolClient, done: (err: null | Error, conn: PoolClient) => void) => void;

package/dist/users/index.d.ts

@@ -1,15 +1,42 @@
-import { RestModels } from '@niledatabase/js';
 import { Config } from '../utils/Config';
 import { NileRequest, NileResponse } from '../utils/Requester';
+export interface CreateBasicUserRequest {
+    email: string;
+    password: string;
+    preferredName?: string;
+    newTenant?: string;
+}
+export declare const LoginUserResponseTokenTypeEnum: {
+    readonly AccessToken: "ACCESS_TOKEN";
+    readonly RefreshToken: "REFRESH_TOKEN";
+    readonly IdToken: "ID_TOKEN";
+};
+export type LoginUserResponseTokenTypeEnum = (typeof LoginUserResponseTokenTypeEnum)[keyof typeof LoginUserResponseTokenTypeEnum];
+export interface LoginUserResponseToken {
+    jwt: string;
+    maxAge: number;
+    type: LoginUserResponseTokenTypeEnum;
+}
+export interface LoginUserResponse {
+    [key: string]: any;
+    id: string;
+    token: LoginUserResponseToken;
+}
+export interface User {
+    id?: string;
+    tenants?: Set<string>;
+    email?: string;
+    preferredName?: string;
+}
 export default class Users extends Config {
     constructor(config: Config);
     get baseUrl(): string;
     get usersUrl(): string;
     get tenantUsersUrl(): string;
-    createTenantUser: (req: NileRequest<RestModels.CreateBasicUserRequest>, init?: RequestInit) => NileResponse<RestModels.LoginUserResponse>;
-    listUsers: (req: NileRequest<void> | Headers, init?: RequestInit) => NileResponse<RestModels.User[]>;
-    updateUser: (userId: string, req: NileRequest<RestModels.UpdateUserRequest>, init?: RequestInit) => NileResponse<RestModels.User>;
-    listTenantUsers: (req: NileRequest<void> | Headers, init?: RequestInit) => NileResponse<RestModels.User[]>;
+    createTenantUser: (req: NileRequest<CreateBasicUserRequest>, init?: RequestInit) => NileResponse<LoginUserResponse>;
+    listUsers: (req: NileRequest<void> | Headers, init?: RequestInit) => NileResponse<User[]>;
+    updateUser: (userId: string, req: NileRequest<User>, init?: RequestInit) => NileResponse<User>;
+    listTenantUsers: (req: NileRequest<void> | Headers, init?: RequestInit) => NileResponse<User[]>;
     get meUrl(): string;
-    me: (req: NileRequest<void>, init?: RequestInit) => NileResponse<RestModels.User>;
+    me: (req: NileRequest<void>, init?: RequestInit) => NileResponse<User>;
 }

package/dist/utils/Config/envVars.d.ts

@@ -0,0 +1,16 @@
+import 'dotenv/config';
+import { ServerConfig } from '../../types';
+export type EnvConfig = {
+    logger?: string;
+    config?: ServerConfig;
+};
+export declare const getDatbaseId: (cfg: EnvConfig) => string | undefined;
+export declare const getUsername: (cfg: EnvConfig) => string | undefined;
+export declare const getPassword: (cfg: EnvConfig) => string | undefined;
+export declare const getInfoBearer: (cfg: EnvConfig) => string;
+export declare const getToken: (cfg: EnvConfig) => string | undefined;
+export declare const getDatabaseName: (cfg: EnvConfig) => string | null;
+export declare const getTenantId: (cfg: EnvConfig) => string | null;
+export declare const getBasePath: (cfg: EnvConfig) => string;
+export declare function getDbHost(cfg: EnvConfig): string;
+export declare function getDbPort(cfg: EnvConfig): number;

package/dist/utils/{Config.d.ts → Config/index.d.ts}

@@ -1,4 +1,4 @@
-import { PgConnectionConfig, PoolConfig, ServerConfig } from '../types';
+import { NilePoolConfig, ServerConfig } from '../../types';
 declare class ApiConfig {
     cookieKey?: string;
     basePath?: string;
@@ -11,14 +11,13 @@ declare class ApiConfig {
     get token(): string | undefined;
     set token(value: string | undefined);
 }
-type DBConfig = {
-    connection: PgConnectionConfig;
-    pool?: PoolConfig;
-};
 export declare class Config {
-    database: string;
-    workspace: string;
-    db: DBConfig;
+    user: string;
+    password: string;
+    databaseId: string;
+    databaseName: string;
+    debug: boolean;
+    db: NilePoolConfig;
     api: ApiConfig;
     private _tenantId?;
     private _userId?;
@@ -26,6 +25,6 @@ export declare class Config {
     set tenantId(value: string | undefined | null);
     get userId(): string | undefined | null;
     set userId(value: string | undefined | null);
-    constructor(_config?: ServerConfig);
+    constructor(config: ServerConfig, allowPhoneHome?: boolean);
 }
 export {};

package/dist/utils/Logger.d.ts

@@ -0,0 +1,7 @@
+import { ServerConfig } from '../types';
+import { Config } from './Config';
+export default function Logger(config: void | Config | ServerConfig, ...params: unknown[]): {
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+};

package/dist/utils/Requester/types.d.ts

@@ -1,4 +1,3 @@
-import { RestModels } from '@niledatabase/js';
 interface NileBody<R, B> {
     readonly body: ReadableStream<Uint8Array> | null | B;
     readonly bodyUsed: boolean;
@@ -48,5 +47,42 @@ interface NRequest<T> extends NileBody<any, T> {
     clone(): Request;
 }
 export type NileRequest<T> = NRequest<T> | T;
-export type NileResponse<T> = Promise<NResponse<T & RestModels.APIError>>;
+export declare const APIErrorErrorCodeEnum: {
+    readonly InternalError: "internal_error";
+    readonly BadRequest: "bad_request";
+    readonly EntityNotFound: "entity_not_found";
+    readonly DuplicateEntity: "duplicate_entity";
+    readonly InvalidCredentials: "invalid_credentials";
+    readonly UnknownOidcProvider: "unknown_oidc_provider";
+    readonly ProviderAlreadyExists: "provider_already_exists";
+    readonly ProviderConfigError: "provider_config_error";
+    readonly ProviderMismatch: "provider_mismatch";
+    readonly ProviderUpdateError: "provider_update_error";
+    readonly SessionStateMissing: "session_state_missing";
+    readonly SessionStateMismatch: "session_state_mismatch";
+    readonly OidcCodeMissing: "oidc_code_missing";
+};
+export type APIErrorErrorCodeEnum = (typeof APIErrorErrorCodeEnum)[keyof typeof APIErrorErrorCodeEnum];
+export interface APIError {
+    [key: string]: any | any;
+    /**
+     *
+     * @type {string}
+     * @memberof APIError
+     */
+    errorCode: APIErrorErrorCodeEnum;
+    /**
+     *
+     * @type {string}
+     * @memberof APIError
+     */
+    message: string;
+    /**
+     *
+     * @type {number}
+     * @memberof APIError
+     */
+    statusCode: number;
+}
+export type NileResponse<T> = Promise<NResponse<T & APIError>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niledatabase/server",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [
@@ -47,6 +47,9 @@
     "@apidevtools/swagger-cli": "^4.0.4",
     "@babel/core": "^7.23.3",
     "@types/jest": "^29.5.9",
+    "@types/mime": "^4.0.0",
+    "@types/pg": "^8.11.4",
+    "@types/sync-fetch": "^0",
     "@typescript-eslint/parser": "^5.62.0",
     "babel-loader": "^9.1.3",
     "dts-cli": "^2.0.3",
@@ -62,10 +65,11 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "@niledatabase/js": "^1.0.0",
+    "dotenv": "^16.4.5",
+    "install": "^0.13.0",
     "jose": "^4.15.4",
-    "knex": "^2.5.1",
-    "pg": "^8.11.3"
+    "pg": "^8.11.3",
+    "sync-fetch": "^0.5.2"
   },
-  "gitHead": "c3be0e6a94604cf7576629c5ac9318a2cc5eb68e"
+  "gitHead": "a0ba85caf9f5a842cf3b2bcd5605e5ac0ea60999"
 }