@svgrid/enterprise 2.5.3 → 2.6.0

package/src/studio/introspect-openapi.ts

@@ -1,252 +0,0 @@
-/**
- * Import an OpenAPI 3.x document (JSON) into Studio entities + REST data sources.
- * Point at a spec and get a modelled app: each REST resource ( `GET /pets` +
- * `GET /pets/{id}` + POST/PUT/DELETE ) becomes one EntitySchema and one
- * `RestSource`, with fields mapped from the resource's JSON Schema.
- *
- * v1 scope: OpenAPI 3.x JSON only (YAML deferred), single-file `$ref` into
- * `components/schemas`. Pure + Svelte-free like the rest of the studio core.
- */
-import type { EntityField, EntityFieldType, EntitySchema } from '../schema.js'
-import type { EntityDataSource, RequestParam, RestSource } from './project.js'
-
-type Json = Record<string, unknown>
-type OpenApiDoc = {
-  openapi?: string
-  servers?: Array<{ url?: string }>
-  paths?: Record<string, Json>
-  components?: { schemas?: Record<string, Json> }
-}
-
-export type OpenApiImport = {
-  entities: EntitySchema[]
-  sources: Record<string, EntityDataSource>
-  /** Non-fatal notes (skipped paths, unresolved refs) to surface in the UI. */
-  warnings: string[]
-}
-
-const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'] as const
-
-/** Resolve a local `#/components/schemas/Foo` ref (one level). */
-function resolveRef(doc: OpenApiDoc, ref: string): Json | null {
-  const m = ref.match(/^#\/components\/schemas\/(.+)$/)
-  if (!m) return null
-  return (doc.components?.schemas?.[m[1]!] as Json) ?? null
-}
-
-/** Follow a `$ref` to its target schema (guards against a self/cyclic ref). */
-function deref(doc: OpenApiDoc, node: Json | undefined, seen = new Set<string>()): Json | null {
-  if (!node) return null
-  const ref = node['$ref']
-  if (typeof ref === 'string') {
-    if (seen.has(ref)) return null
-    seen.add(ref)
-    return deref(doc, resolveRef(doc, ref) ?? undefined, seen)
-  }
-  return node
-}
-
-/** The component-schema name a `$ref` points at, or null. */
-function refName(node: Json | undefined): string | null {
-  const ref = node?.['$ref']
-  const m = typeof ref === 'string' ? ref.match(/^#\/components\/schemas\/(.+)$/) : null
-  return m ? m[1]! : null
-}
-
-const titleCase = (s: string) => s.replace(/[-_]+/g, ' ').replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/^./, (c) => c.toUpperCase()).trim()
-const singular = (s: string) => (s.endsWith('ies') ? s.slice(0, -3) + 'y' : s.endsWith('ses') ? s.slice(0, -2) : s.endsWith('s') && !s.endsWith('ss') ? s.slice(0, -1) : s)
-
-/** Map one JSON-Schema property to an EntityField type (+ enum options). */
-function fieldType(doc: OpenApiDoc, prop: Json, entityByRef: Map<string, string>): { type: EntityFieldType; options?: Array<{ value: string; label: string }>; relation?: string } {
-  // A `$ref` to a schema that became one of our entities -> a relation.
-  const rn = refName(prop)
-  if (rn && entityByRef.has(rn)) return { type: 'relation', relation: entityByRef.get(rn)! }
-  const schema = deref(doc, prop) ?? prop
-  const enumVals = schema['enum']
-  if (Array.isArray(enumVals) && enumVals.every((v) => typeof v === 'string' || typeof v === 'number')) {
-    return { type: 'enum', options: enumVals.map((v) => ({ value: String(v), label: titleCase(String(v)) })) }
-  }
-  const t = schema['type']
-  const fmt = schema['format']
-  if (t === 'integer' || t === 'number') return { type: 'number' }
-  if (t === 'boolean') return { type: 'boolean' }
-  if (t === 'array' || t === 'object') return { type: 'json' }
-  if (t === 'string') {
-    if (fmt === 'date') return { type: 'dateString' }
-    if (fmt === 'date-time') return { type: 'datetime' }
-    return { type: 'text' }
-  }
-  return { type: 'text' }
-}
-
-/** Object schema -> EntityField[]. `id`/pk detection + required + relations. */
-function schemaToFields(doc: OpenApiDoc, objectSchema: Json, entityByRef: Map<string, string>): EntityField[] {
-  const props = (deref(doc, objectSchema)?.['properties'] as Record<string, Json> | undefined) ?? {}
-  const required = new Set((deref(doc, objectSchema)?.['required'] as string[] | undefined) ?? [])
-  const fields: EntityField[] = []
-  for (const [name, rawProp] of Object.entries(props)) {
-    const ft = fieldType(doc, rawProp, entityByRef)
-    const isPk = name === 'id' || name === '_id'
-    const field: EntityField = {
-      field: name,
-      label: titleCase(name),
-      type: ft.type,
-      ...(isPk ? { primaryKey: true } : {}),
-      ...(required.has(name) && !isPk ? { required: true } : {}),
-      ...(ft.options ? { options: ft.options } : {}),
-      ...(ft.relation ? { relation: { entity: ft.relation, labelField: 'name', foreignKey: name } } : {}),
-    }
-    fields.push(field)
-  }
-  return fields
-}
-
-/** The item schema for a resource: the 200 response of GET-by-id, else the array
- *  item of the list response, else the POST request body. */
-function itemSchemaFor(doc: OpenApiDoc, ops: Record<string, Json>): Json | null {
-  const bodySchema = (op: Json | undefined, kind: 'response' | 'request'): Json | null => {
-    if (!op) return null
-    const content =
-      kind === 'response'
-        ? ((op['responses'] as Json | undefined)?.['200'] as Json | undefined)?.['content']
-        : (op['requestBody'] as Json | undefined)?.['content']
-    const json = (content as Json | undefined)?.['application/json'] as Json | undefined
-    return (json?.['schema'] as Json | undefined) ?? null
-  }
-  const byId = bodySchema(ops.getOne, 'response')
-  if (byId) return deref(doc, byId)
-  const list = bodySchema(ops.list, 'response')
-  if (list) {
-    const s = deref(doc, list)
-    if (s?.['type'] === 'array') return deref(doc, s['items'] as Json)
-    // wrapped: { data: [ item ] } / { items: [...] } / { results: [...] }
-    for (const key of ['data', 'items', 'results', 'rows']) {
-      const wrapped = deref(doc, (s?.['properties'] as Record<string, Json> | undefined)?.[key])
-      if (wrapped?.['type'] === 'array') return deref(doc, wrapped['items'] as Json)
-    }
-  }
-  const created = bodySchema(ops.create, 'request')
-  return created ? deref(doc, created) : null
-}
-
-/** The `application/json` schema node of an operation's 200 response, else null. */
-function responseSchema(op: Json | undefined): Json | undefined {
-  const content = ((op?.['responses'] as Json | undefined)?.['200'] as Json | undefined)?.['content'] as Json | undefined
-  return (content?.['application/json'] as Json | undefined)?.['schema'] as Json | undefined
-}
-
-/** The dotted rows path for a list response ('data'/'items'/...), or undefined
- *  when the response is a bare array. */
-function rowsPathFor(doc: OpenApiDoc, listOp: Json | undefined): string | undefined {
-  const s = deref(doc, responseSchema(listOp))
-  if (!s || s['type'] === 'array') return undefined
-  for (const key of ['data', 'items', 'results', 'rows']) {
-    if (deref(doc, (s['properties'] as Record<string, Json> | undefined)?.[key])?.['type'] === 'array') return key
-  }
-  return undefined
-}
-
-function paramsFor(doc: OpenApiDoc, op: Json | undefined): RequestParam[] {
-  const raw = (op?.['parameters'] as Json[] | undefined) ?? []
-  const out: RequestParam[] = []
-  for (const p of raw) {
-    const param = deref(doc, p) ?? p
-    const loc = param['in']
-    const name = param['name']
-    if (typeof name !== 'string' || (loc !== 'query' && loc !== 'path' && loc !== 'header')) continue
-    out.push({ name, location: loc, type: 'string' })
-  }
-  return out
-}
-
-/** Split "/pets/{petId}" -> { collection: "/pets", isItem: true }. A collection
- *  path ends in a static segment; an item path ends in a `{param}`. */
-function classifyPath(path: string): { collection: string; isItem: boolean } {
-  const segs = path.split('/').filter(Boolean)
-  if (segs.length && /^\{.+\}$/.test(segs.at(-1)!)) return { collection: '/' + segs.slice(0, -1).join('/'), isItem: true }
-  return { collection: path, isItem: false }
-}
-
-/** Parse + introspect an OpenAPI 3.x JSON document into entities + REST sources. */
-export function introspectOpenApi(specText: string): OpenApiImport {
-  let doc: OpenApiDoc
-  try {
-    doc = JSON.parse(specText) as OpenApiDoc
-  } catch {
-    throw new Error('Could not parse the OpenAPI document. v1 supports JSON only - convert a YAML spec to JSON first (e.g. https://editor.swagger.io export).')
-  }
-  if (!doc || typeof doc !== 'object' || !doc.paths) throw new Error('Not an OpenAPI document: no "paths" object found.')
-
-  const warnings: string[] = []
-  const baseUrl = (doc.servers?.[0]?.url ?? '').replace(/\/+$/, '')
-
-  // Group operations by resource (collection path).
-  type Res = { name: string; collection: string; ops: Record<string, Json> }
-  const byCollection = new Map<string, Res>()
-  for (const [path, item] of Object.entries(doc.paths)) {
-    const { collection, isItem } = classifyPath(path)
-    const segs = collection.split('/').filter(Boolean)
-    const last = segs.at(-1)
-    if (!last || /^\{.+\}$/.test(last)) { warnings.push(`Skipped path "${path}" (no clear resource name).`); continue }
-    const name = singular(last).replace(/[^a-zA-Z0-9]+/g, '_').toLowerCase()
-    const res = byCollection.get(collection) ?? { name, collection, ops: {} }
-    for (const method of HTTP_METHODS) {
-      const op = item[method] as Json | undefined
-      if (!op) continue
-      if (method === 'get') res.ops[isItem ? 'getOne' : 'list'] = op
-      else if (method === 'post' && !isItem) res.ops.create = op
-      else if ((method === 'put' || method === 'patch') && isItem) res.ops.update = op
-      else if (method === 'delete' && isItem) res.ops.delete = op
-    }
-    byCollection.set(collection, res)
-  }
-
-  // Two passes: map each resource's component schema NAME -> entity name first,
-  // so a property that `$ref`s another resource's schema becomes a relation.
-  const resources = [...byCollection.values()].filter((r) => r.ops.list || r.ops.getOne || r.ops.create)
-  const entityByRef = new Map<string, string>()
-  for (const r of resources) {
-    for (const opKey of ['getOne', 'list', 'create'] as const) {
-      const op = r.ops[opKey]
-      const schema = responseSchema(op) ?? ((((op?.['requestBody'] as Json | undefined)?.['content'] as Json | undefined)?.['application/json'] as Json | undefined)?.['schema'] as Json | undefined)
-      const direct = refName(schema)
-      if (direct) entityByRef.set(direct, r.name)
-      const arrItem = refName(deref(doc, schema)?.['items'] as Json | undefined)
-      if (arrItem) entityByRef.set(arrItem, r.name)
-    }
-  }
-
-  const entities: EntitySchema[] = []
-  const sources: Record<string, EntityDataSource> = {}
-  const seenNames = new Set<string>()
-  for (const r of resources) {
-    let name = r.name
-    while (seenNames.has(name)) name = name + '_'
-    seenNames.add(name)
-    const item = itemSchemaFor(doc, r.ops)
-    if (!item) { warnings.push(`Resource "${r.collection}" has no readable schema - skipped.`); continue }
-    const fields = schemaToFields(doc, item, entityByRef)
-    if (!fields.length) { warnings.push(`Resource "${r.collection}" resolved no fields - skipped.`); continue }
-    if (!fields.some((f) => f.primaryKey)) {
-      const idish = fields.find((f) => /id$/i.test(f.field))
-      if (idish) idish.primaryKey = true
-      else fields.unshift({ field: 'id', label: 'Id', type: 'text', primaryKey: true })
-    }
-    const idField = fields.find((f) => f.primaryKey)!.field
-    entities.push({ name, label: titleCase(name), idField, fields })
-    const path = r.collection.replace(/^\/+/, '')
-    const source: RestSource = {
-      kind: 'rest',
-      baseUrl,
-      path,
-      method: 'GET',
-      params: paramsFor(doc, r.ops.list),
-      idField,
-      ...(rowsPathFor(doc, r.ops.list) ? { rowsPath: rowsPathFor(doc, r.ops.list) } : {}),
-    }
-    sources[name] = source
-  }
-
-  if (!entities.length) throw new Error('No REST resources with a readable schema were found in the document.')
-  return { entities, sources, warnings }
-}

package/src/studio/introspect-prisma.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { introspectPrisma, introspectPrismaAll } from './introspect-prisma'
-
-const SCHEMA = `
-datasource db { provider = "postgresql"; url = env("DATABASE_URL") }
-generator client { provider = "prisma-client-js" }
-
-enum Role {
-  ADMIN
-  USER
-}
-
-model User {
-  id        Int      @id @default(autoincrement())
-  email     String   @unique
-  name      String?
-  role      Role     @default(USER)
-  createdAt DateTime @default(now())
-  posts     Post[]
-}
-
-model Post {
-  id       Int    @id @default(autoincrement())
-  title    String
-  views    Int    @default(0)
-  author   User   @relation(fields: [authorId], references: [id])
-  authorId Int
-}
-`
-
-describe('introspectPrisma', () => {
-  it('maps scalar types and marks the @id as the read-only key', () => {
-    const s = introspectPrisma(SCHEMA, 'User')
-    const byField = Object.fromEntries(s.fields.map((f) => [f.field, f]))
-    expect(s.name).toBe('User')
-    expect(byField.id!.primaryKey).toBe(true)
-    expect(byField.id!.readonly).toBe(true)
-    expect(byField.email!.type).toBe('text')
-    expect(byField.createdAt!.type).toBe('datetime')
-  })
-
-  it('treats a missing `?` as required and `?` as optional', () => {
-    const byField = Object.fromEntries(introspectPrisma(SCHEMA, 'User').fields.map((f) => [f.field, f]))
-    expect(byField.email!.required).toBe(true)
-    expect(byField.name!.required).toBeUndefined()
-  })
-
-  it('reads an enum field with its options', () => {
-    const role = introspectPrisma(SCHEMA, 'User').fields.find((f) => f.field === 'role')!
-    expect(role.type).toBe('enum')
-    expect(role.options?.map((o) => o.value)).toEqual(['ADMIN', 'USER'])
-  })
-
-  it('turns a @relation FK into a relation field and skips the navigation field', () => {
-    const s = introspectPrisma(SCHEMA, 'Post')
-    const fieldNames = s.fields.map((f) => f.field)
-    expect(fieldNames).toContain('authorId')
-    expect(fieldNames).not.toContain('author') // navigation field is virtual
-    const rel = s.fields.find((f) => f.field === 'authorId')!
-    expect(rel.type).toBe('relation')
-    expect(rel.relation?.entity).toBe('User')
-  })
-
-  it('defaults to the first model when none is named', () => {
-    expect(introspectPrisma(SCHEMA).name).toBe('User')
-  })
-
-  it('throws when there is no model', () => {
-    expect(() => introspectPrisma('generator client {}')).toThrow(/no .*model/)
-  })
-})
-
-describe('composite primary key (join table)', () => {
-  const JOIN = `
-    model PostTag {
-      postId Int
-      tagId  Int
-      post   Post @relation(fields: [postId], references: [id])
-      tag    Tag  @relation(fields: [tagId], references: [id])
-      @@id([postId, tagId])
-    }
-    model Post { id Int @id }
-    model Tag { id Int @id }
-  `
-  it('keys off the first @@id member and keeps the other as a relation', () => {
-    const s = introspectPrisma(JOIN, 'PostTag')
-    expect(s.idField).toBe('postId')
-    expect(s.fields.find((f) => f.field === 'tagId')?.type).toBe('relation')
-  })
-})
-
-describe('introspectPrismaAll', () => {
-  it('returns every model, linked', () => {
-    const all = introspectPrismaAll(SCHEMA)
-    expect(all.map((s) => s.name)).toEqual(['User', 'Post'])
-    const rel = all.find((s) => s.name === 'Post')!.fields.find((f) => f.field === 'authorId')!
-    expect(rel.relation?.entity).toBe('User')
-  })
-})

package/src/studio/introspect-prisma.ts

@@ -1,175 +0,0 @@
-/**
- * Prisma introspection - turn a `schema.prisma` into `EntitySchema`s, the peer
- * of the Drizzle reader in `introspect.ts`. Same contract: a pure, best-effort
- * text parse (no `@prisma/*` dependency, no code execution), funnelled through
- * the shared `buildEntitySchema` so grid + form come out identical to every
- * other introspection path.
- *
- *   - `introspectPrisma(source, model?)` -> one model's schema.
- *   - `introspectPrismaAll(source)`      -> every model, linked (relations
- *     resolve their display field from the related model).
- *
- * Scalar types map to entity field types; `@id` marks the key; a missing `?`
- * means required; `enum` blocks become enum fields; and a `@relation(fields:
- * [fk], references: [id])` navigation turns the scalar `fk` column into a
- * relation field with a searchable lookup.
- */
-import { linkRelationLabels, type EntityFieldType, type EntitySchema } from '../schema.js'
-import { buildEntitySchema, type IntrospectedColumn } from '../sources/schema-from-columns.js'
-
-/** Prisma scalar type -> entity field type. Unknown scalars fall back to text. */
-const PRISMA_TYPE_MAP: Record<string, EntityFieldType> = {
-  Int: 'number',
-  BigInt: 'number',
-  Float: 'number',
-  Decimal: 'number',
-  String: 'text',
-  Boolean: 'boolean',
-  DateTime: 'datetime',
-  Json: 'json',
-  Bytes: 'text',
-}
-
-type PrismaModel = { name: string; body: string }
-type Relations = Map<string, { table: string; column: string }>
-
-/** Find each `model X { ... }` / `enum X { ... }` block and return its inner body. */
-function blocks(source: string, keyword: 'model' | 'enum'): Array<{ name: string; body: string }> {
-  const out: Array<{ name: string; body: string }> = []
-  const re = new RegExp(`${keyword}\\s+(\\w+)\\s*\\{`, 'g')
-  let m: RegExpExecArray | null
-  while ((m = re.exec(source)) !== null) {
-    const open = m.index + m[0].length - 1
-    let depth = 0
-    for (let i = open; i < source.length; i++) {
-      const ch = source[i]
-      if (ch === '{') depth++
-      else if (ch === '}' && --depth === 0) {
-        out.push({ name: m[1]!, body: source.slice(open + 1, i) })
-        re.lastIndex = i
-        break
-      }
-    }
-  }
-  return out
-}
-
-/** Strip comments and blank lines; return meaningful field/attribute lines. */
-function lines(body: string): string[] {
-  return body
-    .split('\n')
-    .map((l) => l.replace(/\/\/.*$/, '').trim())
-    .filter(Boolean)
-}
-
-/** Enum block -> its member names (one identifier per line, `@map` ignored). */
-function enumValues(body: string): string[] {
-  return lines(body)
-    .map((l) => l.match(/^(\w+)/)?.[1])
-    .filter((v): v is string => Boolean(v))
-}
-
-/** Collect `@relation(fields: [fk], references: [ref])` FKs declared in a model. */
-function relationsOf(modelLines: string[]): Relations {
-  const rels: Relations = new Map()
-  for (const line of modelLines) {
-    const rel = line.match(/@relation\([^)]*fields:\s*\[(\w+)\][^)]*references:\s*\[(\w+)\]/)
-    if (!rel) continue
-    const type = line.match(/^\w+\s+(\w+)/)?.[1]
-    if (type) rels.set(rel[1]!, { table: type, column: rel[2]! })
-  }
-  return rels
-}
-
-/** Field names of a composite key (`@@id([a, b])`), else empty. */
-function compositeKey(modelLines: string[]): string[] {
-  for (const line of modelLines) {
-    const m = line.match(/^@@id\(\s*\[([^\]]*)\]/)
-    if (m) return m[1]!.split(',').map((s) => s.trim()).filter(Boolean)
-  }
-  return []
-}
-
-/** Parse one model body into neutral columns, skipping navigation fields. */
-function columnsFor(model: PrismaModel, modelNames: Set<string>, enums: Map<string, string[]>): IntrospectedColumn[] {
-  const modelLines = lines(model.body)
-  const relations = relationsOf(modelLines)
-  const columns: IntrospectedColumn[] = []
-
-  for (const line of modelLines) {
-    if (line.startsWith('@@')) continue // block attribute (@@id, @@index, @@map, ...)
-    const field = line.match(/^(\w+)\s+(\w+)(\[\])?(\?)?(.*)$/)
-    if (!field) continue
-    const [, name, baseType, list, optional, attrs = ''] = field
-
-    // A navigation field (points at another model) is virtual - the stored FK
-    // scalar column carries the relation. Skip it (its @relation was captured).
-    if (modelNames.has(baseType!)) continue
-
-    const col: IntrospectedColumn = { name: name! }
-    if (enums.has(baseType!)) col.enumValues = enums.get(baseType!)
-    else col.type = PRISMA_TYPE_MAP[baseType!] ?? 'text'
-
-    if (/@id\b/.test(attrs)) col.primaryKey = true
-    // Required = not optional and not a list.
-    if (!optional && !list) col.required = true
-
-    const ref = relations.get(name!)
-    if (ref) col.references = { table: ref.table, column: ref.column }
-
-    columns.push(col)
-  }
-
-  // Composite key (`@@id([a, b])`): flag the members. buildEntitySchema keys off
-  // the first (a join table's screen targets its first key column).
-  const composite = compositeKey(modelLines)
-  if (composite.length && !columns.some((c) => c.primaryKey)) {
-    for (const c of columns) if (composite.includes(c.name)) c.primaryKey = true
-  }
-
-  return columns
-}
-
-function parseModels(source: string): {
-  models: PrismaModel[]
-  modelNames: Set<string>
-  enums: Map<string, string[]>
-} {
-  const models = blocks(source, 'model')
-  const enums = new Map(blocks(source, 'enum').map((e) => [e.name, enumValues(e.body)]))
-  const modelNames = new Set(models.map((m) => m.name))
-  return { models, modelNames, enums }
-}
-
-/** Parse one Prisma model into an `EntitySchema`. Defaults to the first model. */
-export function introspectPrisma(source: string, model?: string): EntitySchema {
-  const { models, modelNames, enums } = parseModels(source)
-  if (models.length === 0) {
-    throw new Error('introspectPrisma: no `model X { ... }` definition found in source')
-  }
-  const picked = model ? models.find((m) => m.name === model) : models[0]
-  if (!picked) throw new Error(`introspectPrisma: model "${model}" not found in source`)
-
-  const columns = columnsFor(picked, modelNames, enums)
-  if (columns.length === 0) {
-    throw new Error(`introspectPrisma: parsed model "${picked.name}" but found no fields`)
-  }
-  return buildEntitySchema(picked.name, columns)
-}
-
-/**
- * Parse **every** model in a `schema.prisma` into a linked set of schemas.
- * Foreign keys become relation fields and `linkRelationLabels` resolves each
- * lookup's display field from the related model.
- */
-export function introspectPrismaAll(source: string): EntitySchema[] {
-  const { models, modelNames, enums } = parseModels(source)
-  if (models.length === 0) {
-    throw new Error('introspectPrisma: no `model X { ... }` definition found in source')
-  }
-  const schemas = models
-    .map((m) => ({ m, columns: columnsFor(m, modelNames, enums) }))
-    .filter(({ columns }) => columns.length > 0)
-    .map(({ m, columns }) => buildEntitySchema(m.name, columns))
-  return linkRelationLabels(schemas)
-}