@ordinlabs/wsm-types 2.2.2

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "@ordinlabs/wsm-types",
+    "version": "2.2.2",
+    "description": "",
+    "main": "dist/index.js",
+    "scripts": {
+        "clean": "rimraf dist",
+        "clean:modules": "rimraf node_modules",
+        "prettify": "prettier \"src/**/*.ts\" --write",
+        "build": "tsc -b",
+        "build:prod": "npm run clean && npm run build",
+        "test": "jest --verbose",
+        "watch": "tsc --watch"
+    },
+    "license": "LGPL-3.0-only",
+    "devDependencies": {
+        "@ordinlabs/prettier-config-wsm": "^2.2.2",
+        "@types/jest": "^27.4.1",
+        "@types/jsbn": "^1.2.30",
+        "jest": "26.6.0",
+        "prettier": "^2.6.2",
+        "rimraf": "^3.0.2",
+        "ts-jest": "^26.5.6",
+        "typescript": "^4.9"
+    },
+    "dependencies": {
+        "@kubernetes/client-node": "^0.20.0",
+        "cuid": "^2.1.8",
+        "ip-address": "^8.1.0",
+        "moment": "^2.29.3",
+        "moment-timezone": "^0.5.34"
+    },
+    "prettier": "@ordinlabs/prettier-config-wsm",
+    "gitHead": "fda36ef46bf4d285c80dd7c20d5e350ed09d37a6",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
+}

package/src/accessRules.ts

@@ -0,0 +1,18 @@
+export type AllowListEntry = {
+    value: string;
+    comment?: string;
+};
+
+export type HttpAccessRule = {
+    id: string;
+    anyIp: boolean;
+    allowedIps?: AllowListEntry[];
+    anyPath: boolean;
+    allowedPaths?: AllowListEntry[];
+    enableCloudEditing?: boolean;
+    comment?: string;
+};
+
+export type HasHttpAccessRules = {
+    httpAccessRules?: HttpAccessRule[];
+};

package/src/apiKey.ts

@@ -0,0 +1,16 @@
+export type APIKeyInfo = {
+    id: string;
+    userId: string;
+    note: string;
+    created: number;
+    expiresAt: number;
+};
+
+export type APIKey = APIKeyInfo & {
+    secret: string;
+};
+
+export type CreateAPIKeyRequest = {
+    note: string;
+    expiresAt: number;
+};

package/src/base.ts

@@ -0,0 +1,35 @@
+export type HasId<K = string> = {
+    id: K;
+};
+
+export type DatedObject = {
+    created: number;
+    lastModified: number;
+};
+
+export type HasKubeStructureVersion = {
+    kubeStructureVersion: number;
+};
+
+export type IdAndName<K = string> = {
+    id: K;
+    name: string;
+};
+
+export type DataObject<K = string> = HasId<K> & DatedObject;
+export type NamedDataObject<K = string> = IdAndName<K> & DatedObject;
+export type UnsavedDataObject<T extends DataObject> = Omit<
+    T,
+    'id' | 'created' | 'lastModified'
+>;
+
+export type Optional<Type, Key extends keyof Type> = Omit<Type, Key> &
+    Partial<Pick<Type, Key>>;
+
+export function isEntity(obj: any): obj is DataObject<string> {
+    return typeof obj?.id === 'string' && isUnsavedEntity(obj);
+}
+
+export function isUnsavedEntity(obj: any): obj is UnsavedDataObject<any> {
+    return typeof obj === 'object' && typeof obj?.name === 'string';
+}

package/src/clientConfig.ts

@@ -0,0 +1,13 @@
+export type ClientConfig = {
+    appVersion: string;
+    sshHost: string;
+    sshNamePrefix: string;
+    workspaceDomain: string;
+    projectTemplateDefaults: Record<string, object>;
+    workspaceTemplateDefaults: Record<string, object>;
+    serverIpRanges: string[];
+    defaultTimezone: string;
+    authProviders: string[];
+    approvedGoogleDomains: string[];
+    vpnSupportEnabled: boolean;
+};

package/src/developer.ts

@@ -0,0 +1,29 @@
+import { ApplicationRole } from './rbac';
+import {
+    isEntity,
+    isUnsavedEntity,
+    NamedDataObject,
+    UnsavedDataObject,
+} from './base';
+
+export type DeveloperInfo = NamedDataObject & {
+    email: string;
+    appRole?: ApplicationRole;
+};
+
+export type Developer = DeveloperInfo & {
+    /** @deprecated use `publicKeys` instead */
+    publicKey?: string;
+    publicKeys: string[];
+    timezone?: string;
+};
+
+export type UnsavedDeveloper = UnsavedDataObject<Developer>;
+
+export function isUnsavedDeveloper(obj: any): obj is UnsavedDeveloper {
+    return isUnsavedEntity(obj) && typeof obj.email === 'string';
+}
+
+export function isDeveloper(obj: any): obj is Developer {
+    return isEntity(obj) && isUnsavedDeveloper(obj);
+}

package/src/group.ts

@@ -0,0 +1,38 @@
+import {
+    isEntity,
+    isUnsavedEntity,
+    NamedDataObject,
+    UnsavedDataObject,
+} from './base';
+import { GroupRole } from './rbac';
+import { UserAssociation, UserAssociationId } from './memberships';
+
+export type GroupInfo = NamedDataObject;
+export type MyGroupInfo = GroupInfo & {
+    role?: GroupRole;
+};
+export type Group = GroupInfo;
+export type UnsavedGroup = UnsavedDataObject<Group>;
+
+export function isUnsavedGroup(obj: any): obj is UnsavedGroup {
+    return isUnsavedEntity(obj);
+}
+
+export function isGroup(obj: any): obj is Group {
+    return isEntity(obj) && isUnsavedGroup(obj);
+}
+
+// User memberships
+
+export type UserGroupRoleId = UserAssociationId & {
+    groupId: string;
+};
+export type UserGroupRole = UserAssociation<GroupRole, UserGroupRoleId>;
+
+export function isUserGroupRoleId(obj: any): obj is UserGroupRoleId {
+    return typeof obj?.userId === 'string' && typeof obj?.groupId === 'string';
+}
+
+export function isUserGroupRole(obj: any): obj is UserGroupRole {
+    return isUserGroupRoleId(obj.id) && typeof obj?.role === 'string';
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+export * from './accessRules';
+export * from './apiKey';
+export * from './base';
+export * from './clientConfig';
+export * from './developer';
+export * from './group';
+export * from './login';
+export * from './memberships';
+export * from './navData';
+export * from './network';
+export * from './node';
+export * from './project';
+export * from './publicKey';
+export * from './reflection';
+export * from './reporting';
+export * from './requests';
+export * from './session';
+export * from './workspace';
+export * from './k8s';
+export * from './nginx-ingress-types';
+export * from './rbac';

package/src/k8s.ts

@@ -0,0 +1,4 @@
+export type HasNameAndNamespace = {
+    metadata: { name: string; namespace: string };
+};
+export type HasName = { metadata: { name: string } };

package/src/login.ts

@@ -0,0 +1,36 @@
+import { Developer } from './developer';
+import { NavData } from './navData';
+
+export type PasswordOptions = {
+    mustChange: boolean;
+};
+
+export type PasswordMetadata = PasswordOptions & {
+    failureCount: number;
+    lastChanged: number;
+};
+
+export const BAD_LOGIN_CREDENTIALS = 1;
+export const TOO_MANY_LOGIN_FAILURES = 2;
+export const LOGIN_BLOCKED = 3;
+export type LoginErrorCode =
+    | typeof BAD_LOGIN_CREDENTIALS
+    | typeof TOO_MANY_LOGIN_FAILURES
+    | typeof LOGIN_BLOCKED;
+export type LoginRequest = {
+    username: string;
+    password: string;
+    rememberMe: boolean;
+};
+export type LoginSuccess = {
+    success: true;
+    mustChangePassword: boolean;
+    developer: Developer;
+};
+export type LoginFailure = {
+    success: false;
+    errorCode: LoginErrorCode;
+};
+export type LoginResult = LoginSuccess | LoginFailure;
+export type RPCLoginSuccess = LoginSuccess & { navData: NavData };
+export type RPCLoginResult = RPCLoginSuccess | LoginFailure;

package/src/memberships.ts

@@ -0,0 +1,12 @@
+import { HasId } from './base';
+
+export type UserAssociationId = {
+    userId: string;
+};
+
+export type UserAssociation<
+    T extends string,
+    I extends UserAssociationId
+> = HasId<I> & {
+    role: T;
+};

package/src/navData.ts

@@ -0,0 +1,16 @@
+import { ClientConfig } from './clientConfig';
+import { WorkspaceInfo } from './workspace';
+import { MyProjectInfo } from './project';
+import { DeveloperInfo } from './developer';
+import { MyGroupInfo } from './group';
+import { NodeInfo, RunningPodInfo } from './node';
+
+export type NavData = {
+    config: ClientConfig;
+    workspaces: WorkspaceInfo[];
+    projects: MyProjectInfo[];
+    developers: DeveloperInfo[];
+    groups: MyGroupInfo[];
+    nodes: NodeInfo[];
+    runningPods: RunningPodInfo;
+};

package/src/network.ts

@@ -0,0 +1,35 @@
+import { DataObject, Optional, UnsavedDataObject } from './base';
+
+export type PortMapTypes = 'xdebug' | 'custom';
+
+export type PortMap = {
+    type: PortMapTypes;
+    label: string;
+    from: number;
+    to: number;
+};
+
+export type UnsavedPortMap = Optional<PortMap, 'from'>;
+
+export type WireGuardPeer = DataObject & {
+    label: string;
+    userId: string;
+    publicKey: string;
+    privateKey: string;
+    preSharedKey: string;
+    ipAddress: string;
+    portMaps?: (PortMap | UnsavedPortMap)[];
+};
+
+export type UnsavedWireGuardPeer = Optional<
+    UnsavedDataObject<WireGuardPeer>,
+    'publicKey' | 'privateKey' | 'preSharedKey' | 'ipAddress'
+>;
+
+export function isUnsavedWireGuardPeer(obj: any): obj is UnsavedWireGuardPeer {
+    return typeof obj === 'object' && typeof obj?.id === 'undefined';
+}
+
+export function isWireGuardPeer(obj: any): obj is WireGuardPeer {
+    return typeof obj === 'object' && typeof obj?.id === 'string';
+}

package/src/nginx-ingress-types.ts

@@ -0,0 +1,218 @@
+/*
+See https://docs.nginx.com/nginx-ingress-controller/configuration/virtualserver-and-virtualserverroute-resources/
+*/
+
+import {
+    KubernetesListObject,
+    KubernetesObject,
+} from '@kubernetes/client-node';
+
+export type VirtualServer = KubernetesObject & {
+    spec: VirtualServerSpec;
+    status?: {
+        externalEndpoints?: {
+            ip?: string;
+            ports?: string;
+        }[];
+        message?: string;
+        reason?: string;
+        state?: string;
+    };
+};
+
+export type VirtualServerRoute = KubernetesObject & {
+    spec: VirtualServerRouteSpec;
+};
+
+export type VirtualServerList = KubernetesListObject<VirtualServer>;
+export type VirtualServerRouteList = KubernetesListObject<VirtualServerRoute>;
+
+export type VirtualServerSpec = {
+    host: string;
+    tls?: TLS;
+    policies?: Policy[];
+    upstreams?: Upstream[];
+    routes?: Route[];
+    ingressClassName?: string;
+    'http-snippets'?: string;
+    'server-snippets'?: string;
+};
+
+export type VirtualServerRouteSpec = {
+    host: string;
+    upstreams?: Upstream[];
+    subroutes?: Subroute[];
+    ingressClassName?: string;
+};
+
+export type Subroute = {
+    path: string;
+    policies?: Policy[];
+    action?: Action;
+    splits?: Split[];
+    matches?: Matches;
+    errorPages?: ErrorPage[];
+    'location-snippets'?: string;
+};
+
+export type TLS = {
+    secret?: string;
+    redirect?: {
+        enable?: boolean;
+        code?: number;
+        basedOn?: string;
+    };
+};
+
+export type Policy = {
+    name: string;
+    namespace?: string;
+};
+
+type Timeouts = {
+    'connect-timeout'?: string;
+    'read-timeout'?: string;
+    'send-timeout'?: string;
+};
+
+export type Upstream = Timeouts & {
+    name: string;
+    service: string;
+    subselector?: Record<string, string>;
+    'use-cluster-ip'?: boolean;
+    port: number;
+    'lb-method'?: string;
+    'fail-timeout'?: string;
+    'max-fails'?: number;
+    'max-conns'?: number;
+    keepalive?: number;
+    'next-upstream'?: string;
+    'next-upstream-timeout'?: string;
+    'next-upstream-tries'?: number;
+    'client-max-body-size'?: string;
+    tls?: {
+        enable?: boolean;
+    };
+    healthCheck?: HealthCheck;
+    'slow-start'?: string;
+    queue?: {
+        size: number;
+        timeout?: string;
+    };
+    buffering?: boolean;
+    buffers?: {
+        number: number;
+        size: string;
+    };
+    'buffer-size'?: string;
+};
+
+export type HealthCheck = Timeouts & {
+    enable?: boolean;
+    path?: string;
+    interval?: string;
+    jitter?: string;
+    fails?: number;
+    passes?: number;
+    port?: number;
+    tls?: {
+        enable?: boolean;
+    };
+    headers: Header[];
+    statusMatch: string;
+};
+
+type Header = {
+    name: string;
+    value?: string;
+};
+
+export type Route = {
+    path: string;
+    policies?: Policy[];
+    action?: Action;
+    splits?: Split[];
+    matches?: Matches;
+    route?: string;
+    errorPages?: ErrorPage[];
+    'location-snippets'?: string;
+};
+
+type PassAction = {
+    pass: string;
+};
+
+type RedirectAction = {
+    redirect: {
+        url: string;
+        code?: number;
+    };
+};
+
+type ReturnAction = {
+    return: {
+        code?: number;
+        type?: string;
+        body: string;
+    };
+};
+
+type ProxyAction = {
+    proxy: {
+        upstream: string;
+        requestHeaders?: ProxyRequestHeaders;
+        responseHeaders?: ProxyResponseHeaders;
+        rewritePath?: string;
+    };
+};
+
+type ProxyRequestHeaders = {
+    pass?: boolean;
+    set: Header[];
+};
+
+type ProxyResponseHeaders = {
+    hide?: boolean;
+    pass?: string[];
+    ignore?: string[];
+    add?: AddHeader[];
+};
+
+type AddHeader = Header & {
+    always?: boolean;
+};
+
+export type Action = PassAction | RedirectAction | ReturnAction | ProxyAction;
+
+export type Split = {
+    weight: number;
+    action: Action;
+};
+
+export type Matches = {
+    conditions: Condition[];
+    action?: Action;
+    splits?: Split[];
+};
+
+export type Condition = {
+    header?: string;
+    cookie?: string;
+    argument?: string;
+    variable?: string;
+    value: string;
+};
+
+export type ErrorPage = {
+    codes: number[];
+    redirect?: {
+        code?: number;
+        url: string;
+    };
+    return?: {
+        code?: number;
+        type?: string;
+        body: string;
+        headers?: Header[];
+    };
+};

package/src/node.ts

@@ -0,0 +1,13 @@
+import { IdAndName } from './base';
+
+export type NodeInfo = IdAndName & {
+    launchDate: number;
+    labels: Record<string, string>;
+    annotations: Record<string, string>;
+    ip: string;
+};
+
+export type RunningPodInfo = {
+    projects: Record<string, number>;
+    workspaces: Record<string, number>;
+};