mchades commented on code in PR #12900: URL: https://github.com/apache/gravitino/pull/12900#discussion_r4266030529
########## web-v2/web/src/app/catalogs/rightContent/CreateSemanticModelDialog.js: ########## @@ -0,0 +1,289 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 client' + +import React, { useEffect, useRef, useState } from 'react' +import { Form, Input, Modal, Spin, Typography } from 'antd' +import { useScrolling } from 'react-use' +import RenderPropertiesFormItem from '@/components/EntityPropertiesFormItem' +import { validateMessages, dialogContentMaxHeigth, mismatchName } from '@/config' +import { nameRegex } from '@/lib/utils/regex' +import { useResetFormOnCloseModal } from '@/lib/hooks/use-reset' +import { cn } from '@/lib/utils/tailwind' +import { useAppDispatch } from '@/lib/hooks/useStore' +import { + formatSemanticModelDefinition, + genSemanticModelUpdates, + parseSemanticModelDefinition +} from '@/lib/utils/semanticModel' +import { createSemanticModel, updateSemanticModel, getSemanticModelDetails } from '@/lib/store/metalakes' + +const { Paragraph } = Typography +const { TextArea } = Input + +const definitionPlaceholder = `{ + "datasets": [ + { + "name": "orders", + "source": { "namespace": ["sales", "mart"], "name": "orders" }, + "fields": [] + } + ] +}` + +const defaultValues = { + name: '', + comment: '', + definition: '', + properties: [] +} + +export default function CreateSemanticModelDialog({ ...props }) { + const { open, setOpen, metalake, catalog, schema, editSemanticModel, onSaved } = props + const [confirmLoading, setConfirmLoading] = useState(false) + const [isLoading, setIsLoading] = useState(false) + const [cacheData, setCacheData] = useState() + const scrollRef = useRef(null) + const loadedRef = useRef(false) + const scrolling = useScrolling(scrollRef) + const [bottomShadow, setBottomShadow] = useState(false) + const [topShadow, setTopShadow] = useState(false) + const [form] = Form.useForm() + const dispatch = useAppDispatch() + + useResetFormOnCloseModal({ + form, + open + }) + + const handScroll = () => { + if (scrollRef.current) { + const { scrollTop, scrollHeight, clientHeight } = scrollRef.current + if (scrollHeight > clientHeight + scrollTop) { + setTopShadow(true) + setBottomShadow(scrollTop > 0) + } else if (scrollHeight === clientHeight + scrollTop) { + setTopShadow(false) + setBottomShadow(scrollTop > 0) + } + } + } + + useEffect(() => { + scrollRef.current && handScroll() + }, [scrolling]) + + useEffect(() => { + if (open && editSemanticModel && !loadedRef.current) { + loadedRef.current = true + + const initLoad = async () => { + setIsLoading(true) + try { + const { payload } = await dispatch( + getSemanticModelDetails({ metalake, catalog, schema, semanticModel: editSemanticModel }) + ) + const loaded = payload?.semanticModel + setCacheData(loaded) + form.setFieldValue('name', loaded?.name) + form.setFieldValue('comment', loaded?.comment) + form.setFieldValue('definition', formatSemanticModelDefinition(loaded?.definition)) + let index = 0 + Object.entries(loaded?.properties || {}).forEach(([key, value]) => { + form.setFieldValue(['properties', index, 'key'], key) + form.setFieldValue(['properties', index, 'value'], value) + index++ + }) + setIsLoading(false) + } catch (e) { + setIsLoading(false) + } + } + initLoad() + } + + // Reset loadedRef when dialog closes + if (!open) { + loadedRef.current = false + } + }, [open, editSemanticModel, metalake, catalog, schema]) + + const validateDefinition = (rule, value) => { + const { errors } = parseSemanticModelDefinition(value) + + return errors.length + ? Promise.reject( + <ul className='list-disc pl-4'> + {errors.map(error => ( + <li key={error}>{error}</li> + ))} + </ul> + ) + : Promise.resolve() + } + + const handleSubmit = e => { + e.preventDefault() + form + .validateFields() + .then(async values => { + const { definition } = parseSemanticModelDefinition(values.definition) + + setConfirmLoading(true) + + const submitData = { + name: values.name.trim(), + comment: values.comment, + definition, + properties: Object.fromEntries((values.properties || []).map(({ key, value }) => [key, value])) + } + + let result + if (editSemanticModel) { + const updates = genSemanticModelUpdates(cacheData, submitData) + if (updates.length) { + result = await dispatch( + updateSemanticModel({ + metalake, + catalog, + schema, + semanticModel: editSemanticModel, + data: { updates } + }) + ) + } + } else { + result = await dispatch(createSemanticModel({ data: submitData, metalake, catalog, schema })) + } + + if (!result?.payload?.err && !result?.error) { + setOpen(false) + if (result) await onSaved?.(result.payload) + } + }) + .catch(info => { + if (info?.errorFields?.length) { + form.scrollToField(info.errorFields[0].name) + } else { + console.error(info) + } + }) + .finally(() => setConfirmLoading(false)) + } + + const handleCancel = () => { + setOpen(false) + } + + return ( + <> + <Modal + title={!editSemanticModel ? 'Create Semantic Model' : 'Edit Semantic Model'} + open={open} + onOk={handleSubmit} + okText='Submit' + okButtonProps={{ + 'data-refer': 'handle-submit-semantic-model', + disabled: isLoading || (!!editSemanticModel && !cacheData) + }} + maskClosable={false} + keyboard={false} + width={800} + confirmLoading={confirmLoading} + onCancel={handleCancel} + > + <Paragraph type='secondary'> + {!editSemanticModel + ? 'Create a new semantic model.' + : `Edit the semantic model ${editSemanticModel}. The definition is replaced as a whole.`} + </Paragraph> + <div + className={cn('relative', { + 'after:absolute after:-bottom-10 after:left-0 after:right-0 after:h-10 after:shadow-[0px_-10px_8px_-8px_rgba(5,5,5,0.1)]': + topShadow, + 'before:absolute before:-top-10 before:left-0 before:right-0 before:h-10 before:z-10 before:shadow-[0px_10px_8px_-8px_rgba(5,5,5,0.1)]': + bottomShadow + })} + > + <div className='overflow-auto' style={{ maxHeight: `${dialogContentMaxHeigth}px` }} ref={scrollRef}> + <Spin spinning={isLoading}> + <Form + form={form} + initialValues={defaultValues} + layout='vertical' + name='semanticModelForm' + validateMessages={validateMessages} + > + <Form.Item + name='name' + label='Semantic Model Name' + rules={[ + { required: true }, + { type: 'string', max: 64 }, + { pattern: new RegExp(nameRegex) }, + { + validator: (_, value) => + value?.trim() === 'ossie' + ? Promise.reject(new Error('The name "ossie" is reserved for OSSIE import.')) + : Promise.resolve() + } + ]} + messageVariables={{ label: 'semantic model name' }} + > + <Input data-refer='semantic-model-name-field' placeholder={mismatchName} /> + </Form.Item> + <Form.Item name='comment' label='Comment'> + <TextArea data-refer='semantic-model-comment-field' /> + </Form.Item> + <Form.Item + name='definition' + label='Definition' + extra='The datasets, relationships and metrics of the semantic model, as JSON. The server validates the sources.' + rules={[{ required: true }, { validator: validateDefinition }]} + messageVariables={{ label: 'definition' }} + > + <TextArea Review Comment: UX: provide focused editing for semantic metadata Changing one field's label, description, dialect expression, or AI context currently requires editing the entire model definition as JSON. Please add a form-based Edit action for the selected dataset, field, relationship, or metric, with a corresponding editor for model-level AI context. Keep the JSON editor as an advanced option, and preserve untouched entities, additional AI-context keys, and vendor extensions when composing the existing whole-definition update. This would make routine metadata maintenance practical without requiring users to understand the full JSON contract. ########## web-v2/web/src/app/catalogs/rightContent/entitiesContent/SemanticModelDetailsPage.js: ########## @@ -0,0 +1,576 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 client' + +import { useMemo, useState } from 'react' +import { Button, Divider, Flex, Popover, Space, Spin, Table, Tabs, Tag, Tooltip, Typography, message } from 'antd' +import { useAntdColumnResize } from 'react-antd-column-resize' +import useResizeObserver from 'use-resize-observer' +import { useRouter, useSearchParams } from 'next/navigation' +import Tags from '@/components/CustomTags' +import GetOwner from '@/components/GetOwner' +import Icons from '@/components/Icons' +import PropertiesContent from '@/components/PropertiesContent' +import { useAppDispatch, useAppSelector } from '@/lib/hooks/useStore' +import { getSemanticModelDetails } from '@/lib/store/metalakes' +import { copyToClipboard } from '@/lib/utils' +import { formatToDateTime, isValidDate } from '@/lib/utils/date' +import { formatSemanticModelDefinition } from '@/lib/utils/semanticModel' +import SemanticModelAIContext from './SemanticModelAIContext' +import SemanticModelExport from './SemanticModelExport' +import SemanticModelExtensions from './SemanticModelExtensions' +import CreateSemanticModelDialog from '../CreateSemanticModelDialog' + +const { Title, Paragraph } = Typography + +const sourceFullName = source => { + if (!source) { + return '-' + } + + return [...(source.namespace || []), source.name].filter(Boolean).join('.') +} + +const renderExpression = expression => { + const dialects = expression?.dialects || [] + + if (!dialects.length) { + return <span>-</span> + } + + return ( + <Space direction='vertical' size={2}> + {dialects.map((dialect, index) => ( + <span key={`${dialect?.dialect}-${index}`}> + <Tag>{dialect?.dialect}</Tag> + <span className='font-mono text-xs'>{dialect?.expression}</span> + </span> + ))} + </Space> + ) +} + +const renderColumns = columns => <span className='font-mono text-xs'>{(columns || []).join(', ') || '-'}</span> + +const hasMetadata = entity => !!entity.aiContext || entity.customExtensions?.length > 0 + +const renderMetadata = (entity, label) => ( + <> + <SemanticModelAIContext context={entity?.aiContext} label={`${label} AI Context`} /> + <SemanticModelExtensions extensions={entity?.customExtensions} label={`${label} Vendor Extensions`} /> + </> +) + +export default function SemanticModelDetailsPage() { + const searchParams = useSearchParams() + const router = useRouter() + const dispatch = useAppDispatch() + const metalake = searchParams.get('metalake') + const catalog = searchParams.get('catalog') + const schema = searchParams.get('schema') + const semanticModelName = searchParams.get('semanticModel') + const auth = useAppSelector(state => state.auth) + const { anthEnable } = auth + const store = useAppSelector(state => state.metalakes) + const semanticModel = store.activatedDetails + const [tabKey, setTabKey] = useState('Datasets') + const [openEdit, setOpenEdit] = useState(false) + const { ref, width } = useResizeObserver() + + const definition = semanticModel?.definition + const properties = semanticModel?.properties + const createdAt = semanticModel?.audit?.createTime + const createdAtText = !createdAt || !isValidDate(createdAt) ? '-' : formatToDateTime(createdAt) + const lastModifiedAt = semanticModel?.audit?.lastModifiedTime + const lastModifiedText = !lastModifiedAt || !isValidDate(lastModifiedAt) ? '-' : formatToDateTime(lastModifiedAt) + const metadataObjectFullName = `${catalog}.${schema}.${semanticModelName}` + + const datasets = useMemo( + () => (definition?.datasets || []).map(dataset => ({ ...dataset, key: dataset.name })), + [definition] + ) + + const relationships = useMemo( + () => (definition?.relationships || []).map(relationship => ({ ...relationship, key: relationship.name })), + [definition] + ) + + const metrics = useMemo( + () => (definition?.metrics || []).map(metric => ({ ...metric, key: metric.name })), + [definition] + ) + + const definitionText = useMemo(() => formatSemanticModelDefinition(definition), [definition]) + + const tagContent = ( + <div> + <Tags readOnly={true} metadataObjectType={'semantic_model'} metadataObjectFullName={metadataObjectFullName} /> + </div> + ) + + const propertyContent = <PropertiesContent properties={properties} /> + + const onSaved = async updated => { + if (updated.name !== semanticModelName) { + const params = new URLSearchParams(searchParams.toString()) + params.set('semanticModel', updated.name) + router.replace(`/catalogs?${params.toString()}`) + } else { + await dispatch(getSemanticModelDetails({ metalake, catalog, schema, semanticModel: updated.name, init: true })) + } + } + + const onCopyDefinition = async () => { + try { + await copyToClipboard(definitionText) + message.success('Definition copied!') + } catch (err) { + console.error('Failed to copy definition: ', err) + message.error('Failed to copy definition') + } + } + + const datasetColumns = useMemo( + () => [ + { + title: 'Dataset Name', + dataIndex: 'name', + key: 'name', + width: 200, + ellipsis: true, + sorter: (a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()) + }, + { + title: 'Source', + dataIndex: 'source', + key: 'source', + width: 260, + ellipsis: true, + render: source => <span className='font-mono text-xs'>{sourceFullName(source)}</span> + }, + { + title: 'Primary Key', + dataIndex: 'primaryKey', + key: 'primaryKey', + width: 180, + ellipsis: true, + render: renderColumns + }, + { + title: 'Unique Keys', + dataIndex: 'uniqueKeys', + key: 'uniqueKeys', + width: 220, + render: keys => + keys?.length ? ( + <Space direction='vertical' size={4}> + {keys.map((columns, index) => ( + <Tag key={index}>{renderColumns(columns)}</Tag> + ))} + </Space> + ) : ( + <span>-</span> + ) + }, + { + title: 'Fields', + dataIndex: 'fields', + key: 'fields', + width: 80, + render: fields => <span>{(fields || []).length}</span> + }, + { + title: 'Description', + dataIndex: 'description', + key: 'description', + ellipsis: true, + render: description => <span>{description || '-'}</span> + } + ], + [] + ) + + const fieldColumns = useMemo( + () => [ + { + title: 'Field Name', + dataIndex: 'name', + key: 'name', + width: 220, + render: (name, field) => ( + <div className='break-words'> + <div>{name}</div> + {field.label && <Typography.Text type='secondary'>{field.label}</Typography.Text>} + </div> + ) + }, + { + title: 'Data Type', + dataIndex: 'datatype', + key: 'datatype', + width: 140, + render: datatype => (datatype ? <Tag>{datatype}</Tag> : <span>-</span>) + }, + { + title: 'Time Dimension', + dataIndex: 'dimension', + key: 'dimension', + width: 140, + render: dimension => <span>{dimension?.isTime ? 'Yes' : 'No'}</span> + }, + { + title: 'Expression', + dataIndex: 'expression', + key: 'expression', + render: renderExpression + }, + { + title: 'Description', + dataIndex: 'description', + key: 'description', + ellipsis: true, + render: description => <span>{description || '-'}</span> + } + ], + [] + ) + + const relationshipColumns = useMemo( + () => [ + { + title: 'Relationship Name', + dataIndex: 'name', + key: 'name', + width: 220, + ellipsis: true, + sorter: (a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()) + }, + { title: 'From', dataIndex: 'from', key: 'from', width: 160, ellipsis: true }, + { + title: 'From Columns', + dataIndex: 'fromColumns', + key: 'fromColumns', + width: 200, + ellipsis: true, + render: renderColumns + }, + { title: 'To', dataIndex: 'to', key: 'to', width: 160, ellipsis: true }, + { + title: 'To Columns', + dataIndex: 'toColumns', + key: 'toColumns', + ellipsis: true, + render: renderColumns + } + ], + [] + ) + + const metricColumns = useMemo( + () => [ + { + title: 'Metric Name', + dataIndex: 'name', + key: 'name', + width: 200, + ellipsis: true, + sorter: (a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()) + }, + { + title: 'Data Type', + dataIndex: 'datatype', + key: 'datatype', + width: 140, + render: datatype => (datatype ? <Tag>{datatype}</Tag> : <span>-</span>) + }, + { + title: 'Expression', + dataIndex: 'expression', + key: 'expression', + render: renderExpression + }, + { + title: 'Description', + dataIndex: 'description', + key: 'description', + ellipsis: true, + render: description => <span>{description || '-'}</span> + } + ], + [] + ) + + const tabOptions = [ + { label: 'Datasets', key: 'Datasets' }, + { label: 'Relationships', key: 'Relationships' }, + { label: 'Metrics', key: 'Metrics' }, + { label: 'Definition', key: 'Definition' } + ] + + const { + resizableColumns: datasetResizableColumns, + components: datasetComponents, + tableWidth: datasetTableWidth + } = useAntdColumnResize(() => { + return { columns: datasetColumns, minWidth: 100 } + }, [datasetColumns]) + + const { + resizableColumns: relationshipResizableColumns, + components: relationshipComponents, + tableWidth: relationshipTableWidth + } = useAntdColumnResize(() => { + return { columns: relationshipColumns, minWidth: 100 } + }, [relationshipColumns]) + + const { + resizableColumns: metricResizableColumns, + components: metricComponents, + tableWidth: metricTableWidth + } = useAntdColumnResize(() => { + return { columns: metricColumns, minWidth: 100 } + }, [metricColumns]) + + const expandedFieldsRow = dataset => ( + <div> + {renderMetadata(dataset, dataset.name)} + <Table + data-refer='semantic-model-fields-grid' + size='small' + rowKey={field => field.name} + dataSource={dataset.fields || []} + columns={fieldColumns} + pagination={false} + expandable={{ + expandedRowRender: field => renderMetadata(field, field.name), Review Comment: UX: make field-level AI context discoverable from the field row Reading a field's AI guidance currently requires expanding its dataset, expanding the field row, and then opening the AI Context accordion. The field row only has a generic expand icon, which can also mean vendor extensions, so users cannot tell whether AI guidance exists before expanding it. Please keep the dataset grouping but show a labeled AI Context indicator/action on fields with context and open that content directly, avoiding the additional nested accordion step. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
