@perses-dev/core 0.0.0-snapshot-scatterplot-fix-imports-95e1b59 → 0.0.0-snapshot-explorer-plugin-c4a7621

package/dist/cjs/schema/panel.js

@@ -0,0 +1,106 @@
+// Copyright 2024 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildPanelDefinitionSchema: function() {
+        return buildPanelDefinitionSchema;
+    },
+    buildPanelEditorSchema: function() {
+        return buildPanelEditorSchema;
+    },
+    buildPanelSpecSchema: function() {
+        return buildPanelSpecSchema;
+    },
+    linkSchema: function() {
+        return linkSchema;
+    },
+    panelDefinitionSchema: function() {
+        return panelDefinitionSchema;
+    },
+    panelDisplaySpec: function() {
+        return panelDisplaySpec;
+    },
+    panelEditorSchema: function() {
+        return panelEditorSchema;
+    },
+    panelSpecSchema: function() {
+        return panelSpecSchema;
+    },
+    querySpecSchema: function() {
+        return querySpecSchema;
+    }
+});
+const _zod = require("zod");
+const _plugin = require("./plugin");
+const panelDisplaySpec = _zod.z.object({
+    name: _zod.z.string().min(1, {
+        message: 'Required'
+    }),
+    description: _zod.z.string().optional()
+});
+const querySpecSchema = _zod.z.object({
+    kind: _zod.z.string().min(1),
+    spec: _zod.z.object({
+        plugin: _plugin.pluginSchema
+    })
+});
+const linkSchema = _zod.z.object({
+    name: _zod.z.string().optional(),
+    url: _zod.z.string().min(1),
+    tooltip: _zod.z.string().optional(),
+    renderVariables: _zod.z.boolean().optional(),
+    targetBlank: _zod.z.boolean().optional()
+});
+const panelSpecSchema = _zod.z.object({
+    display: panelDisplaySpec,
+    plugin: _plugin.pluginSchema,
+    queries: _zod.z.array(querySpecSchema).optional(),
+    links: _zod.z.array(linkSchema).optional()
+});
+function buildPanelSpecSchema(pluginSchema) {
+    return _zod.z.object({
+        display: panelDisplaySpec,
+        plugin: pluginSchema,
+        queries: _zod.z.array(querySpecSchema).optional(),
+        links: _zod.z.array(linkSchema).optional()
+    });
+}
+const panelDefinitionSchema = _zod.z.object({
+    kind: _zod.z.literal('Panel'),
+    spec: panelSpecSchema
+});
+function buildPanelDefinitionSchema(pluginSchema) {
+    return _zod.z.object({
+        kind: _zod.z.literal('Panel'),
+        spec: buildPanelSpecSchema(pluginSchema)
+    });
+}
+const panelEditorSchema = _zod.z.object({
+    groupId: _zod.z.number(),
+    panelDefinition: panelDefinitionSchema
+});
+function buildPanelEditorSchema(pluginSchema) {
+    return _zod.z.object({
+        groupId: _zod.z.number(),
+        panelDefinition: buildPanelDefinitionSchema(pluginSchema)
+    });
+}

package/dist/cjs/schema/plugin.js

@@ -0,0 +1,27 @@
+// Copyright 2024 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pluginSchema", {
+    enumerable: true,
+    get: function() {
+        return pluginSchema;
+    }
+});
+const _zod = require("zod");
+const pluginSchema = _zod.z.object({
+    kind: _zod.z.string().min(1, 'Required'),
+    spec: _zod.z.record(_zod.z.string(), _zod.z.any())
+});

package/dist/cjs/schema/role.js

@@ -0,0 +1,86 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    globalRoleSchema: function() {
+        return globalRoleSchema;
+    },
+    permissionSchema: function() {
+        return permissionSchema;
+    },
+    roleSchema: function() {
+        return roleSchema;
+    },
+    roleSpecSchema: function() {
+        return roleSpecSchema;
+    },
+    rolesEditorSchema: function() {
+        return rolesEditorSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const permissionSchema = _zod.z.object({
+    // TODO: use SCOPE & ACTIONS constants
+    actions: _zod.z.array(_zod.z.enum([
+        '*',
+        'create',
+        'read',
+        'update',
+        'delete'
+    ])).nonempty('Must contains at least 1 action'),
+    scopes: _zod.z.array(_zod.z.enum([
+        '*',
+        'Dashboard',
+        'Datasource',
+        'EphemeralDashboard',
+        'Folder',
+        'GlobalDatasource',
+        'GlobalRole',
+        'GlobalRoleBinding',
+        'GlobalSecret',
+        'GlobalVariable',
+        'Project',
+        'Role',
+        'RoleBinding',
+        'Secret',
+        'User',
+        'Variable'
+    ])).nonempty('Must contains at least 1 scope')
+});
+const roleSpecSchema = _zod.z.object({
+    permissions: _zod.z.array(permissionSchema)
+});
+const roleSchema = _zod.z.object({
+    kind: _zod.z.literal('Role'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: roleSpecSchema
+});
+const globalRoleSchema = _zod.z.object({
+    kind: _zod.z.literal('GlobalRole'),
+    metadata: _metadata.metadataSchema,
+    spec: roleSpecSchema
+});
+const rolesEditorSchema = _zod.z.discriminatedUnion('kind', [
+    roleSchema,
+    globalRoleSchema
+]);

package/dist/cjs/schema/rolebinding.js

@@ -0,0 +1,65 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    globalRoleBindingSchema: function() {
+        return globalRoleBindingSchema;
+    },
+    roleBindingSchema: function() {
+        return roleBindingSchema;
+    },
+    roleBindingSpecSchema: function() {
+        return roleBindingSpecSchema;
+    },
+    roleBindingsEditorSchema: function() {
+        return roleBindingsEditorSchema;
+    },
+    subjectSchema: function() {
+        return subjectSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const subjectSchema = _zod.z.object({
+    kind: _zod.z.enum([
+        'User'
+    ]),
+    name: _metadata.nameSchema
+});
+const roleBindingSpecSchema = _zod.z.object({
+    role: _metadata.nameSchema,
+    subjects: _zod.z.array(subjectSchema).nonempty()
+});
+const roleBindingSchema = _zod.z.object({
+    kind: _zod.z.literal('RoleBinding'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: roleBindingSpecSchema
+});
+const globalRoleBindingSchema = _zod.z.object({
+    kind: _zod.z.literal('GlobalRoleBinding'),
+    metadata: _metadata.metadataSchema,
+    spec: roleBindingSpecSchema
+});
+const roleBindingsEditorSchema = _zod.z.discriminatedUnion('kind', [
+    roleBindingSchema,
+    globalRoleBindingSchema
+]);

package/dist/cjs/schema/secret.js

@@ -0,0 +1,174 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    globalSecretSchema: function() {
+        return globalSecretSchema;
+    },
+    secretSchema: function() {
+        return secretSchema;
+    },
+    secretSpecSchema: function() {
+        return secretSpecSchema;
+    },
+    secretsEditorSchema: function() {
+        return secretsEditorSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const secretSpecSchema = _zod.z.object({
+    basicAuth: _zod.z.object({
+        username: _zod.z.string().min(1),
+        password: _zod.z.string().optional(),
+        passwordFile: _zod.z.string().optional()
+    }).superRefine((val, ctx)=>{
+        if (val.password && val.password.length > 0 && val.passwordFile && val.passwordFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'password'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'passwordFile'
+                ]
+            });
+        }
+    }).optional(),
+    authorization: _zod.z.object({
+        type: _zod.z.string().optional(),
+        credentials: _zod.z.string().optional(),
+        credentialsFile: _zod.z.string().optional()
+    }).superRefine((val, ctx)=>{
+        if (val.credentials && val.credentials.length > 0 && val.credentialsFile && val.credentialsFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'credentials'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'credentialsFile'
+                ]
+            });
+        }
+    }).optional(),
+    tlsConfig: _zod.z.object({
+        ca: _zod.z.string().optional(),
+        cert: _zod.z.string().optional(),
+        key: _zod.z.string().optional(),
+        caFile: _zod.z.string().optional(),
+        certFile: _zod.z.string().optional(),
+        keyFile: _zod.z.string().optional(),
+        serverName: _zod.z.string().optional(),
+        insecureSkipVerify: _zod.z.boolean()
+    }).superRefine((val, ctx)=>{
+        if (val.ca && val.ca.length > 0 && val.caFile && val.caFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'ca'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'caFile'
+                ]
+            });
+        }
+        if (val.cert && val.cert.length > 0 && val.certFile && val.certFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'cert'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'certFile'
+                ]
+            });
+        }
+        if (val.key && val.key.length > 0 && val.keyFile && val.keyFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'key'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'keyFile'
+                ]
+            });
+        }
+    }).optional()
+}).superRefine((val, ctx)=>{
+    if (val.basicAuth && val.authorization) {
+        ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: 'Only one of the fields must be defined',
+            path: [
+                'basicAuth'
+            ]
+        });
+        ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: 'Only one of the fields must be defined',
+            path: [
+                'authorization'
+            ]
+        });
+    }
+});
+const secretSchema = _zod.z.object({
+    kind: _zod.z.literal('Secret'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: secretSpecSchema
+});
+const globalSecretSchema = _zod.z.object({
+    kind: _zod.z.literal('GlobalSecret'),
+    metadata: _metadata.metadataSchema,
+    spec: secretSpecSchema
+});
+const secretsEditorSchema = _zod.z.discriminatedUnion('kind', [
+    secretSchema,
+    globalSecretSchema
+]);

package/dist/cjs/schema/user.js

@@ -0,0 +1,57 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    nativeProviderSchema: function() {
+        return nativeProviderSchema;
+    },
+    oauthProvidersSchema: function() {
+        return oauthProvidersSchema;
+    },
+    userSchema: function() {
+        return userSchema;
+    },
+    userSpecSchema: function() {
+        return userSpecSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const nativeProviderSchema = _zod.z.object({
+    password: _zod.z.string().optional()
+});
+const oauthProvidersSchema = _zod.z.object({
+    issuer: _zod.z.string().optional(),
+    email: _zod.z.string().optional(),
+    subject: _zod.z.string().optional()
+});
+const userSpecSchema = _zod.z.object({
+    firstName: _zod.z.string().optional(),
+    lastName: _zod.z.string().optional(),
+    nativeProvider: nativeProviderSchema.optional(),
+    oauthProviders: _zod.z.array(oauthProvidersSchema).optional()
+});
+const userSchema = _zod.z.object({
+    kind: _zod.z.literal('User'),
+    metadata: _metadata.metadataSchema,
+    spec: userSpecSchema
+});

package/dist/cjs/schema/variable.js

@@ -0,0 +1,171 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildVariableDefinitionSchema: function() {
+        return buildVariableDefinitionSchema;
+    },
+    buildVariableListSchema: function() {
+        return buildVariableListSchema;
+    },
+    buildVariableListSpecSchema: function() {
+        return buildVariableListSpecSchema;
+    },
+    buildVariableSpecSchema: function() {
+        return buildVariableSpecSchema;
+    },
+    globalVariableSchema: function() {
+        return globalVariableSchema;
+    },
+    variableDefinitionSchema: function() {
+        return variableDefinitionSchema;
+    },
+    variableDisplaySchema: function() {
+        return variableDisplaySchema;
+    },
+    variableListSchema: function() {
+        return variableListSchema;
+    },
+    variableListSpecSchema: function() {
+        return variableListSpecSchema;
+    },
+    variableSchema: function() {
+        return variableSchema;
+    },
+    variableSpecSchema: function() {
+        return variableSpecSchema;
+    },
+    variableTextSchema: function() {
+        return variableTextSchema;
+    },
+    variableTextSpecSchema: function() {
+        return variableTextSpecSchema;
+    },
+    variablesSchema: function() {
+        return variablesSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const _plugin = require("./plugin");
+const variableDisplaySchema = _zod.z.object({
+    name: _zod.z.string().optional(),
+    description: _zod.z.string().optional(),
+    hidden: _zod.z.boolean().optional()
+});
+const variableListSpecSchema = _zod.z.object({
+    name: _zod.z.string().min(1),
+    display: variableDisplaySchema.optional(),
+    defaultValue: _zod.z.string().or(_zod.z.array(_zod.z.string())).optional(),
+    allowAllValue: _zod.z.boolean(),
+    allowMultiple: _zod.z.boolean(),
+    customAllValue: _zod.z.string().optional(),
+    capturingRegexp: _zod.z.string().optional(),
+    sort: _zod.z.enum([
+        'none',
+        'alphabetical-asc',
+        'alphabetical-desc',
+        'numerical-asc',
+        'numerical-desc',
+        'alphabetical-ci-asc',
+        'alphabetical-ci-desc'
+    ]).optional(),
+    plugin: _plugin.pluginSchema
+});
+function buildVariableListSpecSchema(pluginSchema) {
+    return _zod.z.object({
+        name: _zod.z.string().min(1),
+        display: variableDisplaySchema.optional(),
+        defaultValue: _zod.z.string().or(_zod.z.array(_zod.z.string())).optional(),
+        allowAllValue: _zod.z.boolean(),
+        allowMultiple: _zod.z.boolean(),
+        customAllValue: _zod.z.string().optional(),
+        capturingRegexp: _zod.z.string().optional(),
+        sort: _zod.z.enum([
+            'none',
+            'alphabetical-asc',
+            'alphabetical-desc',
+            'numerical-asc',
+            'numerical-desc',
+            'alphabetical-ci-asc',
+            'alphabetical-ci-desc'
+        ]).optional(),
+        plugin: pluginSchema
+    });
+}
+const variableListSchema = _zod.z.object({
+    kind: _zod.z.literal('ListVariable'),
+    spec: variableListSpecSchema
+});
+function buildVariableListSchema(pluginSchema) {
+    return _zod.z.object({
+        kind: _zod.z.literal('ListVariable'),
+        spec: buildVariableListSpecSchema(pluginSchema)
+    });
+}
+const variableTextSpecSchema = _zod.z.object({
+    name: _zod.z.string().min(1),
+    display: variableDisplaySchema.optional(),
+    value: _zod.z.string(),
+    constant: _zod.z.boolean().optional()
+});
+const variableTextSchema = _zod.z.object({
+    kind: _zod.z.literal('TextVariable'),
+    spec: variableTextSpecSchema
+});
+const variableSpecSchema = _zod.z.discriminatedUnion('kind', [
+    variableTextSchema,
+    variableListSchema
+]);
+function buildVariableSpecSchema(pluginSchema) {
+    return _zod.z.union([
+        variableTextSchema,
+        buildVariableListSchema(pluginSchema)
+    ]);
+}
+const variableSchema = _zod.z.object({
+    kind: _zod.z.literal('Variable'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: variableSpecSchema
+});
+const globalVariableSchema = _zod.z.object({
+    kind: _zod.z.literal('GlobalVariable'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: variableSpecSchema
+});
+const variablesSchema = _zod.z.discriminatedUnion('kind', [
+    variableSchema,
+    globalVariableSchema
+]);
+const variableDefinitionSchema = variableSpecSchema;
+function buildVariableDefinitionSchema(pluginSchema) {
+    return _zod.z.discriminatedUnion('kind', [
+        _zod.z.object({
+            kind: _zod.z.literal('ListVariable'),
+            spec: buildVariableListSpecSchema(pluginSchema)
+        }),
+        _zod.z.object({
+            kind: _zod.z.literal('TextVariable'),
+            spec: variableTextSpecSchema
+        })
+    ]);
+}