@ordinlabs/wsm-types 2.2.2

package/src/project.ts

@@ -0,0 +1,166 @@
+import * as k8s from '@kubernetes/client-node';
+import { VirtualServer } from './nginx-ingress-types';
+import { StoredParamValues } from '@ordinlabs/wsm-common/dist/param-types';
+import { ProjectRole } from './rbac';
+import { WorkspaceTemplateId } from './workspace';
+import { HasHttpAccessRules } from './accessRules';
+import {
+    HasId,
+    HasKubeStructureVersion,
+    isEntity,
+    isUnsavedEntity,
+    NamedDataObject,
+    UnsavedDataObject,
+} from './base';
+import { Developer } from './developer';
+import { UserAssociation, UserAssociationId } from './memberships';
+import { PublicKey } from './publicKey';
+
+export type ProjectTemplateId = 'm2' | 'basicPhp';
+
+export type MageRunType = 'store' | 'website';
+
+export type MageConfig = {
+    name: string;
+    runType: MageRunType;
+    runCode: string;
+};
+
+export type SubdomainConfig = MageConfig & {
+    useStorePaths?: boolean;
+    storePaths?: MageConfig[];
+};
+
+export type ProjectInfo = NamedDataObject & {
+    projectTemplate: ProjectTemplateId;
+    // Must match the name on Workspace
+    workspaceTemplate: WorkspaceTemplateId;
+    lastSeen?: number;
+};
+export type MyProjectInfo = ProjectInfo & {
+    role?: ProjectRole;
+};
+
+export type RepositorySpec = {
+    type?: 'git'; // one day we may support other repositories
+    url: string;
+};
+
+export type Project = ProjectInfo &
+    HasHttpAccessRules &
+    HasKubeStructureVersion & {
+        subdomains: SubdomainConfig[];
+        projectParams: StoredParamValues<any>;
+        workspaceDefaultVolumeSize?: number;
+        // IMPORTANT: Must match the name on Workspace
+        workspaceParams: StoredParamValues<any>;
+        repositories: RepositorySpec[];
+        keyPairIds: string[];
+
+        // Calculated on creation
+        namespace: string;
+        // Calculated on creation
+        efsFolder: string;
+        nfsFolderSize: number;
+    };
+
+export type UnsavedProject = Omit<
+    UnsavedDataObject<Project>,
+    'namespace' | 'efsFolder' | 'kubeStructureVersion'
+>;
+
+export function isUnsavedProject(obj: any): obj is UnsavedProject {
+    if (!isUnsavedEntity(obj)) return false;
+    const p = obj as UnsavedProject;
+    return Array.isArray(p.subdomains) && p.subdomains.length >= 1;
+}
+
+export function isProject(obj: any): obj is Project {
+    if (!isEntity(obj) || !isUnsavedProject(obj)) return false;
+    // TODO: validate optional/defaulted fields
+    return true;
+}
+
+export type ProjectInspection = {
+    project: Project;
+    // The resolved parameters with defaults hydrated
+    resolvedParams: object;
+    ns?: k8s.V1Namespace;
+    // Volume claims used by the pod to store its local data
+    ebsVolumeClaims?: k8s.V1PersistentVolumeClaim[];
+    // Shared volume and claim
+    oldSharedVolumeClaim?: k8s.V1PersistentVolumeClaim;
+    oldSharedVolume?: k8s.V1PersistentVolume;
+    // The deployment that is scaled to manage pods.
+    deployment: k8s.V1Deployment;
+    // The pod containing services for use by workspaces.
+    currentPod?: k8s.V1Pod | null;
+    // The service enabling traffic to the pod.
+    service?: k8s.V1Service;
+    // The ConfigMap containing the developers' public keys.
+    sshConfig?: k8s.V1ConfigMap;
+    // The virtual servers for the project
+    virtualServers?: VirtualServer[];
+    // The public keys associated with this project
+    publicKeys?: PublicKey[];
+    // Events related to the pod
+    events?: k8s.CoreV1Event[];
+};
+
+// Project Memberships
+
+export type UserProjectRoleId = UserAssociationId & {
+    projectId: string;
+};
+export type UserProjectRole = UserAssociation<ProjectRole, UserProjectRoleId>;
+
+export type GitRepoRefInfo = {
+    type: 'tag' | 'note' | 'branch' | 'unknown';
+    name: string;
+    hash: string;
+};
+
+export type GetProjectRepoRefsResult =
+    | {
+          ok: true;
+          refs: GitRepoRefInfo[];
+      }
+    | {
+          ok: false;
+          error: string;
+      };
+
+export function isUserProjectRoleId(obj: any): obj is UserProjectRoleId {
+    return (
+        typeof obj?.userId === 'string' && typeof obj?.projectId === 'string'
+    );
+}
+
+export type ProjectMember = UserProjectRole & {
+    developer?: Developer;
+    fromGroup?: string;
+};
+
+export function isUserProjectRole(obj: any): obj is UserProjectRole {
+    return isUserProjectRoleId(obj.id) && typeof obj?.role === 'string';
+}
+
+// Project group memberships
+
+export type GroupProjectId = {
+    groupId: string;
+    projectId: string;
+};
+export type GroupProject = HasId<GroupProjectId>;
+
+export function isGroupProjectId(obj: any): obj is GroupProjectId {
+    return (
+        obj &&
+        typeof obj.groupId === 'string' &&
+        typeof obj.projectId === 'string'
+    );
+}
+
+export function isGroupProject(obj: any): obj is GroupProject {
+    return obj && isGroupProjectId(obj.id);
+}

package/src/publicKey.ts

@@ -0,0 +1,21 @@
+import { DataObject } from './base';
+
+export type PublicKey = DataObject & {
+    publicKey: string;
+    algorithm: string;
+};
+
+export type AddKeyPairRequest = {
+    projectId: string;
+    mode: 'replace' | 'add';
+};
+
+export type TestGitAccessRequest = {
+    keyId: string;
+    repoUrl: string;
+};
+
+export type TestGitAccessResponse = {
+    ok: boolean;
+    error?: string;
+};

package/src/rbac.ts

@@ -0,0 +1,5 @@
+export type ApplicationRole = 'user' | 'projectManager' | 'admin' | 'blocked';
+
+export type ProjectRole = 'member' | 'admin' | 'owner' | 'guest';
+
+export type GroupRole = 'member' | 'admin' | 'owner';

package/src/reflection.ts

@@ -0,0 +1,19 @@
+import { isUnsavedWorkspace, Workspace } from './workspace';
+import { Developer, isUnsavedDeveloper } from './developer';
+import { isUnsavedProject, Project } from './project';
+import { Group, isUnsavedGroup } from './group';
+
+export type Entity = Developer | Project | Workspace | Group;
+export type EntityType = 'project' | 'workspace' | 'developer' | 'group';
+
+export function getEntityType(obj: any): EntityType | undefined {
+    if (isUnsavedWorkspace(obj)) {
+        return 'workspace';
+    } else if (isUnsavedDeveloper(obj)) {
+        return 'developer';
+    } else if (isUnsavedProject(obj)) {
+        return 'project';
+    } else if (isUnsavedGroup(obj)) {
+        return 'group';
+    }
+}

package/src/reporting.ts

@@ -0,0 +1,60 @@
+export type TimeWindow = {
+    from: number;
+    to: number;
+};
+
+export type TimeGranularity = 'fiveMinutes' | 'hour' | 'day' | 'week' | 'month';
+
+export type UptimeProperties = {
+    startedById?: string;
+    ownerId?: string;
+    projectId?: string;
+    workspaceId?: string;
+};
+
+export type UptimePropertyName = keyof UptimeProperties;
+
+export type UptimeQuery = {
+    when: TimeWindow;
+    where: UptimeProperties;
+};
+
+export type GroupedUptimeQuery = UptimeQuery & {
+    groupBy?: UptimePropertyName;
+};
+
+export type UptimeTimeSeriesQuery = GroupedUptimeQuery & {
+    granularity?: TimeGranularity;
+};
+
+export type UptimeRecord = {
+    groupKey: string;
+    groupLabel?: string;
+    minutes: number;
+};
+
+export type UptimeTimeSeriesEntry = {
+    ts: number;
+    total: number;
+    counts: UptimeRecord[];
+};
+
+export type UptimeTimeSeries = UptimeTimeSeriesEntry[];
+
+export function getAllGroupKeys(series: UptimeTimeSeries): string[] {
+    const groupKeys = new Set<string>();
+    series.forEach((point) =>
+        point.counts.forEach((count) => groupKeys.add(count.groupKey))
+    );
+    return Array.from(groupKeys);
+}
+
+export function getAllGroupLabels(series: UptimeTimeSeries): string[] {
+    const groupLabels = new Set<string>();
+    series.forEach((point) =>
+        point.counts.forEach((count) =>
+            groupLabels.add(count.groupLabel || count.groupKey)
+        )
+    );
+    return Array.from(groupLabels);
+}

package/src/requests.ts

@@ -0,0 +1,27 @@
+import { ApplicationRole } from './rbac';
+
+export type ListPodsRequest = {
+    namespace?: string;
+    labelSelector?: Record<string, string>;
+    fieldSelector?: Record<string, string>;
+};
+
+export type UpdateExpirationRequest = {
+    id: string;
+    deadline: number;
+};
+
+export type AuthRequest = {
+    token: string;
+};
+
+export type UpdateUserRoleRequest = {
+    userId: string;
+    role: ApplicationRole;
+};
+
+export type ChangePasswordRequest = {
+    developerId: string;
+    password?: string;
+    mustChangeOnNextLogin: boolean;
+};

package/src/session.ts

@@ -0,0 +1,14 @@
+import { Developer } from './developer';
+import { NavData } from './navData';
+
+export type ImpersonationResponse = {
+    developer: Developer;
+    navData: NavData;
+    hasPassword: boolean;
+};
+
+export type SessionInfo = {
+    currentUser: Developer | null;
+    impersonatedFrom: Developer | null;
+    hasPassword: boolean;
+};

package/src/workspace.ts

@@ -0,0 +1,121 @@
+import * as k8s from '@kubernetes/client-node';
+import { VirtualServer } from './nginx-ingress-types';
+import { StoredParamValues } from '@ordinlabs/wsm-common/dist/param-types';
+import { HasHttpAccessRules } from './accessRules';
+import {
+    DataObject,
+    HasKubeStructureVersion,
+    isEntity,
+    isUnsavedEntity,
+    NamedDataObject,
+    UnsavedDataObject,
+} from './base';
+import { GitRepoRefInfo } from './project';
+
+export type WorkspaceTemplateId =
+    | 'm2Ubuntu'
+    | 'm1V2'
+    | 'wordpressV2'
+    | 'drupalV2'
+    | 'laravel'
+    | 'm2'
+    | 'm1'
+    | 'wordpress'
+    | 'drupal';
+
+export type WorkspaceInfo = NamedDataObject & {
+    projectId: string;
+    developerId: string;
+    lastSeen?: number;
+};
+
+export type WorkspaceInitType = 'empty' | 'repo' | 'install';
+
+export type WorkspaceInitOptions = {
+    type: WorkspaceInitType;
+    repo?: string;
+    ref?: GitRepoRefInfo;
+};
+
+export type Workspace = WorkspaceInfo &
+    HasHttpAccessRules &
+    HasKubeStructureVersion & {
+        volumeSize: number;
+        initOptions?: WorkspaceInitOptions;
+        initialized: boolean;
+
+        /**
+         * Represents a keypair in PrivateKey/PublicKey collections (shared ID, see crypto.ts).
+         * Used for SSH access into the workspace.
+         */
+        keyPairId?: string;
+
+        // IMPORTANT: These field names must match those in Project
+        workspaceTemplate: WorkspaceTemplateId;
+        workspaceParams: StoredParamValues<any>;
+    };
+
+export type UnsavedWorkspace = Omit<
+    UnsavedDataObject<Workspace>,
+    'kubeStructureVersion' | 'initialized' | 'lastSeen'
+>;
+
+export type WorkspaceDescription = DataObject & {
+    workspaceId: string;
+    description: string;
+    latest: boolean;
+    createdBy: string;
+};
+
+export type UpdateWorkspaceDescriptionRequest = {
+    id: string;
+    description: string;
+};
+
+export type WorkspaceInspection = {
+    workspace: Workspace;
+    resolvedParams: object;
+    deployment: k8s.V1Deployment;
+    currentPod?: k8s.V1Pod;
+    initJob?: k8s.V1Job;
+    pvc?: k8s.V1PersistentVolumeClaim;
+    projectVolumes?: k8s.V1PersistentVolumeClaim[];
+    projectVirtualServers?: VirtualServer[];
+    internalService?: k8s.V1Service;
+    nodePortService?: k8s.V1Service;
+    ebsClaims?: k8s.V1PersistentVolumeClaim[];
+    ingress?: k8s.V1Ingress;
+    virtualServers?: VirtualServer[];
+    events?: k8s.CoreV1Event[];
+    description: WorkspaceDescription | null;
+};
+
+export type StartWorkspaceRequest = {
+    workspaceId: string;
+    expiration?: number;
+};
+
+export function isStartWorkspaceRequest(
+    obj: any
+): obj is StartWorkspaceRequest {
+    return !!obj && typeof obj.workspaceId === 'string';
+}
+
+export type WorkspaceInitLog = DataObject & {
+    log: string;
+};
+
+export function isUnsavedWorkspace(obj: any): obj is UnsavedWorkspace {
+    if (!isUnsavedEntity(obj)) return false;
+    return (
+        typeof obj.developerId === 'string' && typeof obj.projectId === 'string'
+    );
+}
+
+export function isWorkspace(obj: any): obj is Workspace {
+    return isEntity(obj) && isUnsavedWorkspace(obj);
+}
+
+export function isWorkspaceLogRecord(obj: any): obj is WorkspaceInitLog {
+    return typeof obj.log === 'string' && isEntity(obj);
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "include": [
+    "./src"
+  ]
+}