@dovetail-v2/refine 0.0.2 → 0.0.3-0.beta-0

package/lib/src/plugins/model-plugin.js

@@ -0,0 +1,46 @@
+import { CronJobModel, DaemonSetModel, DeploymentModel, EventModel, IngressModel, JobModel, PodModel, ResourceModel, StatefulSetModel, NetworkPolicyModel, } from '../models';
+const ModelMap = {
+    Deployment: DeploymentModel,
+    DaemonSet: DaemonSetModel,
+    StatefulSet: StatefulSetModel,
+    CronJob: CronJobModel,
+    Job: JobModel,
+    Pod: PodModel,
+    Event: EventModel,
+    Ingress: IngressModel,
+    NetworkPolicy: NetworkPolicyModel,
+};
+class ModelPlugin {
+    _globalStore;
+    init(globalStore) {
+        this._globalStore = globalStore;
+    }
+    async processData(res) {
+        const { kind, apiVersion } = res;
+        const items = await Promise.all(res.items.map(item => {
+            const newItem = { ...item };
+            newItem.kind = kind.replace(/List$/g, '');
+            newItem.apiVersion = apiVersion;
+            return this.processItem(newItem);
+        }));
+        return {
+            ...res,
+            items,
+        };
+    }
+    async processItem(item) {
+        const Model = ModelMap[item.kind] || ResourceModel;
+        const result = new Model(item, this._globalStore);
+        await result.init();
+        return result;
+    }
+    restoreData(res) {
+        const newRes = { ...res };
+        newRes.items = res.items.map(item => this.restoreItem(item));
+        return res;
+    }
+    restoreItem(item) {
+        return item._rawYaml;
+    }
+}
+export const modelPlugin = new ModelPlugin();

package/lib/src/plugins/relation-plugin.d.ts

@@ -0,0 +1,27 @@
+import { GlobalStore, Unstructured, UnstructuredList } from 'k8s-api-provider';
+import { LabelSelector, ObjectMeta } from 'kubernetes-types/meta/v1';
+import { ResourceModel } from '../models';
+export type Relation = {
+    kind: string;
+    apiVersion: string;
+    type: 'creates' | 'uses' | 'applies' | 'owner' | 'selects';
+    inbound: boolean;
+    name?: string;
+    namespace?: string;
+    selector?: LabelSelector;
+};
+export type ExtendObjectMeta = ObjectMeta & {
+    relations?: Relation[];
+};
+declare class RelationPlugin {
+    private globalStore?;
+    init(globalStore: GlobalStore): void;
+    processData(res: UnstructuredList): Promise<UnstructuredList>;
+    processItem(item: Unstructured): Promise<ResourceModel>;
+    restoreData(res: UnstructuredList): UnstructuredList;
+    restoreItem(item: Unstructured): Unstructured;
+    private processPodSelector;
+    private appendRelation;
+}
+export declare const relationPlugin: RelationPlugin;
+export {};

package/lib/src/plugins/relation-plugin.js

@@ -0,0 +1,81 @@
+import { omit } from 'lodash';
+class RelationPlugin {
+    globalStore;
+    init(globalStore) {
+        this.globalStore = globalStore;
+    }
+    async processData(res) {
+        const { kind, apiVersion } = res;
+        const items = await Promise.all(res.items.map(item => this.processItem({
+            // TODO: unify this with data-provider getOne method
+            kind: kind.replace(/List$/g, ''),
+            apiVersion,
+            ...omit(item, ['apiVersion', 'kind']),
+        })));
+        return {
+            ...res,
+            items,
+        };
+    }
+    async processItem(item) {
+        this.processPodSelector(item);
+        return item;
+    }
+    restoreData(res) {
+        res.items = res.items.map(item => this.restoreItem(item));
+        return res;
+    }
+    restoreItem(item) {
+        return {
+            ...item,
+            metadata: omit(item.metadata, 'relations'),
+        };
+    }
+    processPodSelector(item) {
+        const { spec, kind } = item;
+        const selector = spec?.selector;
+        if (!selector) {
+            return item;
+        }
+        // TODO: also check apiVersion along with kind
+        if (!kind ||
+            ![
+                'Deployment',
+                'DaemonSet',
+                'StatefulSet',
+                'ReplicaSet',
+                'Job',
+                'Service',
+            ].includes(kind)) {
+            return item;
+        }
+        // empty selector or legacy resources like Service
+        if (!selector.matchLabels && !selector.matchExpressions) {
+            selector.matchLabels = {};
+            for (const key of Object.keys(selector)) {
+                if (key === 'matchLabels') {
+                    continue;
+                }
+                selector.matchLabels[key] = selector[key];
+                delete selector[key];
+            }
+        }
+        this.appendRelation(item, {
+            kind: 'Pod',
+            apiVersion: 'v1',
+            type: kind === 'Service' ? 'selects' : 'creates',
+            selector,
+            inbound: false,
+        });
+        return item;
+    }
+    appendRelation(item, relation) {
+        const metadata = item.metadata;
+        if (!metadata.relations) {
+            metadata.relations = [];
+        }
+        metadata.relations.push(relation);
+        return item;
+    }
+}
+export const relationPlugin = new RelationPlugin();

package/lib/src/plugins/type.d.ts

@@ -0,0 +1,8 @@
+import { Unstructured } from 'k8s-api-provider';
+import { ListMeta } from 'kubernetes-types/meta/v1';
+export type DataList<Output extends Unstructured = Unstructured> = {
+    apiVersion: string;
+    kind: string;
+    metadata: ListMeta;
+    items: Array<Unstructured & Output>;
+};

package/lib/src/plugins/type.js

@@ -0,0 +1 @@
+export {};

package/lib/src/providers/index.js

@@ -0,0 +1 @@
+export { routerProvider } from './router-provider';

package/lib/src/providers/router-provider/index.d.ts

@@ -11,7 +11,7 @@ export declare const convertToNumberIfPossible: (value: string | undefined) => s
 export declare const routerProvider: {
     go: () => ({ to, type, query, hash, options: { keepQuery, keepHash } }: GoConfig) => string | void;
     back: () => () => void;
-    parse: () => () => ParseResponse<Record<string, any>>;
+    parse: () => () => ParseResponse;
     Link: React.ForwardRefExoticComponent<Pick<{
         [prop: string]: any;
         to: string;

package/lib/src/providers/router-provider/index.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable react-hooks/rules-of-hooks */
+import { matchResourceFromRoute, ResourceContext, } from '@refinedev/core';
+import { parse, stringify } from 'qs';
+import React from 'react';
+import { useCallback, useContext } from 'react';
+import { useHistory, useLocation, Link, matchPath, useParams } from 'react-router-dom';
+export const stringifyConfig = {
+    addQueryPrefix: true,
+    skipNulls: true,
+    arrayFormat: 'indices',
+    encode: false,
+    encodeValuesOnly: true,
+};
+export const convertToNumberIfPossible = (value) => {
+    if (typeof value === 'undefined') {
+        return value;
+    }
+    const num = Number(value);
+    if (`${num}` === value) {
+        return num;
+    }
+    return value;
+};
+export const routerProvider = {
+    go: () => {
+        const { search: existingSearch, hash: existingHash } = useLocation();
+        const history = useHistory();
+        const fn = useCallback(({ to, type, query, hash, options: { keepQuery, keepHash } = {} }) => {
+            /** Construct query params */
+            const urlQuery = {
+                ...(keepQuery &&
+                    existingSearch &&
+                    parse(existingSearch, { ignoreQueryPrefix: true })),
+                ...query,
+            };
+            if (urlQuery.to) {
+                urlQuery.to = encodeURIComponent(`${urlQuery.to}`);
+            }
+            const hasUrlQuery = Object.keys(urlQuery).length > 0;
+            /** Get hash */
+            const urlHash = `#${(hash || (keepHash && existingHash) || '').replace(/^#/, '')}`;
+            const hasUrlHash = urlHash.length > 1;
+            const urlTo = to || '';
+            const fullPath = `${urlTo}${hasUrlQuery ? stringify(urlQuery, stringifyConfig) : ''}${hasUrlHash ? urlHash : ''}`;
+            if (type === 'path') {
+                return fullPath;
+            }
+            /** Navigate to the url */
+            return history[type || 'push'](fullPath);
+        }, [existingHash, existingSearch, history]);
+        return fn;
+    },
+    back: () => {
+        const history = useHistory();
+        const fn = useCallback(() => {
+            history.go(-1);
+        }, [history]);
+        return fn;
+    },
+    parse: () => {
+        let params = useParams();
+        const { pathname, search } = useLocation();
+        const { resources } = useContext(ResourceContext);
+        const { resource, action, matchedRoute } = React.useMemo(() => {
+            return matchResourceFromRoute(pathname, resources);
+        }, [resources, pathname]);
+        // params is empty when useParams is used in a component that is not a child of a Route
+        if (Object.entries(params).length === 0 && matchedRoute) {
+            params = matchPath(matchedRoute, pathname)?.params || {};
+        }
+        const fn = useCallback(() => {
+            const parsedSearch = parse(search, { ignoreQueryPrefix: true });
+            const combinedParams = {
+                ...params,
+                ...parsedSearch,
+            };
+            const response = {
+                ...(resource && { resource }),
+                ...(action && { action }),
+                ...(parsedSearch?.id && { id: decodeURIComponent(parsedSearch.id) }),
+                // ...(params?.action && { action: params.action }), // lets see if there is a need for this
+                pathname,
+                params: {
+                    ...combinedParams,
+                    current: convertToNumberIfPossible(combinedParams.current),
+                    pageSize: convertToNumberIfPossible(combinedParams.pageSize),
+                    to: combinedParams.to
+                        ? decodeURIComponent(combinedParams.to)
+                        : undefined,
+                },
+            };
+            return response;
+        }, [pathname, search, params, resource, action]);
+        return fn;
+    },
+    Link: React.forwardRef(function RefineLink(props, ref) {
+        return _jsx(Link, { ...props, ref: ref });
+    }),
+};

package/lib/src/types/index.js

@@ -0,0 +1 @@
+export * from './resource';

package/lib/src/types/resource.d.ts

@@ -1,39 +1,36 @@
 /// <reference types="react" />
-import { i18n } from 'i18next';
-import { ObjectMeta } from 'kubernetes-types/meta/v1';
-import { ShowField } from '../components/ShowContent';
+import { FormModalProps } from 'src/components/FormModal';
+import { ShowConfig } from '../components/ShowContent';
 import { Column } from '../components/Table';
-import { ResourceModel } from '../model';
+import { ResourceModel } from '../models';
 export declare enum RESOURCE_GROUP {
     WORKLOAD = "WORKLOAD",
-    CORE = "CORE"
+    STORAGE = "STORAGE",
+    NETWORK = "NETWORK",
+    CLUSTER = "CLUSTER"
+}
+export declare enum FormType {
+    PAGE = "PAGE",
+    MODAL = "MODAL"
 }
 export type WithId<T> = T & {
     id: string;
 };
-export interface Resource {
-    id: string;
-    apiVersion?: string;
-    /**
-     * Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
-     */
-    kind?: string;
-    /**
-     * Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
-     */
-    metadata?: ObjectMeta;
-}
-export type ResourceConfig<Raw extends Resource = Resource, Model extends ResourceModel = ResourceModel> = {
+export type ResourceConfig<Model extends ResourceModel = ResourceModel> = {
     name: string;
     kind: string;
     basePath: string;
     apiVersion: string;
+    label: string;
     parent?: RESOURCE_GROUP;
-    formatter?: (v: Raw) => Model;
+    formatter?: (v: Model) => Model;
     initValue?: Record<string, unknown>;
-    columns?: (i18n: i18n) => Column<Model>[];
-    showFields?: (i18n: i18n) => ShowField<Model>[][];
+    columns?: () => Column<Model>[];
+    showConfig?: () => ShowConfig<Model>;
     Dropdown?: React.FC<{
-        data: Model;
+        record: Model;
     }>;
+    formType?: FormType;
+    FormModal?: React.FC<FormModalProps>;
+    isCustom?: boolean;
 };

package/lib/src/types/resource.js

@@ -0,0 +1,12 @@
+export var RESOURCE_GROUP;
+(function (RESOURCE_GROUP) {
+    RESOURCE_GROUP["WORKLOAD"] = "WORKLOAD";
+    RESOURCE_GROUP["STORAGE"] = "STORAGE";
+    RESOURCE_GROUP["NETWORK"] = "NETWORK";
+    RESOURCE_GROUP["CLUSTER"] = "CLUSTER";
+})(RESOURCE_GROUP || (RESOURCE_GROUP = {}));
+export var FormType;
+(function (FormType) {
+    FormType["PAGE"] = "PAGE";
+    FormType["MODAL"] = "MODAL";
+})(FormType || (FormType = {}));

package/lib/src/utils/addId.js

@@ -0,0 +1,8 @@
+export function addId(arr, idKey) {
+    return arr.map(e => {
+        return {
+            id: e[idKey],
+            ...e,
+        };
+    });
+}

package/lib/src/utils/download.js

@@ -0,0 +1,9 @@
+export function download(filename, content) {
+    const element = document.createElement('a');
+    element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(content));
+    element.setAttribute('download', filename);
+    element.style.display = 'none';
+    document.body.appendChild(element);
+    element.click();
+    document.body.removeChild(element);
+}

package/lib/src/utils/error.d.ts

@@ -5,7 +5,7 @@ type Cause = {
     message: string;
     field?: string;
 };
-type ErrorResponse = {
+export type ErrorResponseBody = {
     message?: string;
     code?: number;
     reason?: string;
@@ -15,6 +15,6 @@ type ErrorResponse = {
     graphQLErrors?: Cause[];
 };
 export declare function isNetworkError(errors?: Cause[]): boolean;
-export declare function getSubmitError(errorResponse: ErrorResponse | undefined, text: string, i18n: I18n): string;
-export declare function getCommonErrors(response: ErrorResponse, i18n: I18n): string[];
+export declare function getSubmitError(errorResponse: ErrorResponseBody | undefined, text: string, i18n: I18n): string;
+export declare function getCommonErrors(responseBody: ErrorResponseBody, i18n: I18n): string[];
 export {};

package/lib/src/utils/error.js

@@ -0,0 +1,53 @@
+export function isNetworkError(errors) {
+    if (errors?.some(error => error?.code || error?.reason)) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+export function getSubmitError(errorResponse, text, i18n) {
+    return !errorResponse ? i18n.t('dovetail.network_error') : text;
+}
+export function getCommonErrors(responseBody, i18n) {
+    if (!(responseBody?.message ||
+        responseBody?.code ||
+        responseBody?.reason ||
+        responseBody?.details ||
+        responseBody?.graphQLErrors)) {
+        return [];
+    }
+    const causes = responseBody.details?.causes || responseBody.graphQLErrors || [];
+    if (causes.length) {
+        return causes.map(cause => {
+            let params = {};
+            let message = cause.message;
+            try {
+                const info = JSON.parse(cause.message);
+                params = info.params;
+                message = info.message;
+            }
+            catch {
+                return i18n.t([
+                    `error.${cause.reason}`,
+                    `error.${cause.code}`,
+                    `${message}${cause.field ? `(${cause.field})` : ''}`,
+                ], {
+                    ...params,
+                    fallbackLng: '',
+                });
+            }
+            return i18n.t([
+                `error.${cause.reason}`,
+                `error.${cause.code}`,
+                `${message}${cause.field ? `(${cause.field})` : ''}`,
+            ], {
+                ...params,
+                fallbackLng: '',
+            });
+        });
+    }
+    return [
+        i18n.t([`error.${responseBody.code}`, `error.${responseBody.reason}`, responseBody.message || ''], { fallbackLng: '' }),
+    ];
+}

package/lib/src/utils/form.d.ts

@@ -0,0 +1,3 @@
+import { ResourceModel } from 'src/models';
+import { ResourceConfig } from 'src/types';
+export declare function getInitialValues<Model extends ResourceModel = ResourceModel>(config: ResourceConfig<Model>): Record<string, unknown>;

package/lib/src/utils/form.js

@@ -0,0 +1,9 @@
+import { BASE_INIT_VALUE } from 'src/constants/k8s';
+export function getInitialValues(config) {
+    return config.initValue || {
+        apiVersion: config.apiVersion,
+        kind: config.kind,
+        ...BASE_INIT_VALUE,
+        spec: {},
+    };
+}

package/lib/src/utils/k8s.js

@@ -0,0 +1,6 @@
+export function getApiVersion(resourceBasePath) {
+    return resourceBasePath.replace(/^(\/api\/)|(\/apis\/)/, '');
+}
+export function pruneBeforeEdit(v) {
+    delete v.id;
+}

package/lib/src/utils/labels.js

@@ -0,0 +1,15 @@
+export function toLabelStrings(labels = {}) {
+    return Object.keys(labels).map(key => `${key}/${labels[key]}`);
+}
+export function toLabelsArray(labels = {}) {
+    return Object.keys(labels).map(key => ({
+        key,
+        value: labels[key],
+    }));
+}
+export function toLabelsRecord(labels) {
+    return labels.reduce((prev, cur) => {
+        prev[cur.key] = cur.value;
+        return prev;
+    }, {});
+}

package/lib/src/utils/match-selector.d.ts

@@ -0,0 +1,3 @@
+import { LabelSelector } from 'kubernetes-types/meta/v1';
+import { PodModel } from '../models/pod-model';
+export declare function matchSelector(pod: PodModel, selector: LabelSelector): boolean;

package/lib/src/utils/match-selector.js

@@ -0,0 +1,12 @@
+export function matchSelector(pod, selector) {
+    let match = true;
+    // TODO: support complete selector match strategy
+    // https://github.com/rancher/dashboard/blob/master/shell/utils/selector.js#L166
+    for (const key in selector.matchLabels) {
+        if (!pod.metadata?.labels?.[key] ||
+            pod.metadata.labels?.[key] !== selector.matchLabels[key]) {
+            match = false;
+        }
+    }
+    return match;
+}

package/lib/src/utils/openapi.js

@@ -0,0 +1,33 @@
+import { getApiVersion } from 'src/utils/k8s';
+import { resolveRef } from 'src/utils/schema';
+class K8sOpenAPI {
+    resourceBasePath;
+    response = null;
+    apiVersion;
+    constructor(resourceBasePath) {
+        this.resourceBasePath = resourceBasePath;
+        this.apiVersion = getApiVersion(resourceBasePath);
+    }
+    async fetch() {
+        const response = await fetch(`/api/sks/api/v1/clusters/sks-mgmt/proxy/openapi/v3${this.resourceBasePath}`);
+        return response.json();
+    }
+    async findSchema(kind) {
+        const result = this.response || (await this.fetch());
+        const schema = Object.values(result.components.schemas).find(schema => schema['x-kubernetes-group-version-kind']?.some(({ kind: schemaKind, version: schemaVersion, group: schemaGroup }) => kind === schemaKind &&
+            this.apiVersion === `${schemaGroup ? schemaGroup + '/' : ''}${schemaVersion}`));
+        if (schema) {
+            resolveRef(schema, result.components.schemas, {
+                prune: {
+                    description: true,
+                    optional: false,
+                    fields: [],
+                    metadata: true,
+                    xProperty: true,
+                },
+            });
+        }
+        return schema;
+    }
+}
+export default K8sOpenAPI;

package/lib/src/utils/schema.js

@@ -0,0 +1,117 @@
+import { pick } from 'lodash';
+export function generateValueFromSchema(schema, options) {
+    const { generateValue } = options;
+    if (!schema) {
+        return {};
+    }
+    switch (true) {
+        case schema.type === 'string' && 'enum' in schema && Boolean(schema.enum?.length):
+            return generateValue?.(schema) || schema.enum?.[0];
+        case schema.type === 'string':
+            return generateValue?.(schema) || '';
+        case schema.type === 'boolean':
+            return generateValue?.(schema) || false;
+        case schema.type === 'array':
+            if (!schema.minItems ||
+                !schema.items ||
+                typeof schema.items === 'boolean' ||
+                Array.isArray(schema.items)) {
+                return generateValue?.(schema) || [];
+            }
+            return new Array(schema.minItems).fill(generateValueFromSchema(schema.items, options));
+        case schema.type === 'number':
+        case schema.type === 'integer':
+            return generateValue?.(schema) || 0;
+        case schema.type === 'object': {
+            const obj = {};
+            for (const key in schema.properties) {
+                obj[key] = generateValueFromSchema(schema.properties[key], options);
+            }
+            return obj;
+        }
+        case Array.isArray(schema.type) && 'anyOf' in schema && Boolean(schema.anyOf?.length):
+        case Array.isArray(schema.type) &&
+            'oneOf' in schema &&
+            Boolean(schema.oneOf?.length):
+            {
+                const subSchema = (schema.anyOf || schema.oneOf)?.[0];
+                return generateValueFromSchema(subSchema, options);
+            }
+        case 'allOf' in schema && Boolean(schema.allOf?.length):
+            return generateValueFromSchema(schema.allOf?.[0], options);
+        default:
+            return undefined;
+    }
+}
+export function generateSchemaTypeValue(schema) {
+    return generateValueFromSchema(schema, {
+        generateValue(schema) {
+            if (schema.type === 'array' && schema.items) {
+                return generateSchemaTypeValue(schema.items);
+            }
+            else {
+                return schema.type;
+            }
+        },
+    });
+}
+export function resolveRef(schema, schemas, options) {
+    const { prune } = options;
+    if (schema.$ref) {
+        const refKey = schema.$ref.replace('#/components/schemas/', '');
+        Object.assign(schema, schemas[refKey]);
+        if (prune.metadata &&
+            [
+                'io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta',
+                'io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta',
+            ].some(k => refKey.includes(k)) &&
+            schema.properties) {
+            schema.properties = pick(schema.properties, [
+                'name',
+                'namespace',
+                'annotations',
+                'labels',
+            ]);
+        }
+        delete schema.$ref;
+    }
+    for (const schemaKey in schema) {
+        if (prune.xProperty &&
+            schemaKey.startsWith('x-') &&
+            schemaKey !== 'x-kubernetes-group-version-kind') {
+            delete schema[schemaKey];
+        }
+    }
+    switch (true) {
+        case schema.type === 'array':
+            if (Array.isArray(schema.items)) {
+                schema.items.forEach(item => resolveRef(item, schemas, options));
+            }
+            else if (typeof schema.items === 'object') {
+                resolveRef(schema.items, schemas, options);
+            }
+            break;
+        case schema.type === 'object':
+            for (const key in schema.properties) {
+                const subSchema = schema.properties[key];
+                if (prune.optional && !schema.required?.includes(key)) {
+                    delete schema.properties[key];
+                }
+                if (prune.fields.includes(key)) {
+                    delete schema.properties[key];
+                }
+                resolveRef(subSchema, schemas, options);
+            }
+            if (schema.additionalProperties) {
+                resolveRef(schema.additionalProperties, schemas, options);
+            }
+            break;
+        case !!(schema.allOf && schema.allOf[0]):
+            resolveRef(schema.allOf?.[0], schemas, options);
+        default:
+    }
+    if (prune.description) {
+        delete schema.description;
+    }
+    return schema;
+}

package/lib/src/utils/selector.d.ts

@@ -0,0 +1,3 @@
+import { LabelSelector } from 'kubernetes-types/meta/v1';
+import { PodModel } from '../models';
+export declare function matchSelector(pod: PodModel, selector: LabelSelector): boolean;