@svgrid/enterprise 1.2.0 → 2.0.1

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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,175 @@
+/**
+ * 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)
+}

package/src/studio/introspect.test.ts

@@ -0,0 +1,172 @@
+import { describe, expect, it } from 'vitest'
+import { inferType, introspectDrizzle, introspectDrizzleAll, introspectJson } from './introspect'
+
+describe('inferType', () => {
+  it('classifies runtime values', () => {
+    expect(inferType(true)).toBe('boolean')
+    expect(inferType(42)).toBe('number')
+    expect(inferType('hello')).toBe('text')
+    expect(inferType('2026-06-21')).toBe('dateString')
+    expect(inferType('2026-06-21T09:30:00Z')).toBe('datetime')
+    expect(inferType({ a: 1 })).toBe('json')
+    expect(inferType(null)).toBe('text')
+  })
+})
+
+describe('introspectJson', () => {
+  it('unions keys and infers types from the first non-null value', () => {
+    const schema = introspectJson('customers', [
+      { id: '1', name: 'Ann', age: 30, active: true },
+      { id: '2', name: 'Bob', age: null, joined: '2026-01-02' },
+    ])
+    const byField = Object.fromEntries(schema.fields.map((f) => [f.field, f]))
+    expect(schema.name).toBe('customers')
+    expect(byField.name!.type).toBe('text')
+    expect(byField.age!.type).toBe('number')
+    expect(byField.active!.type).toBe('boolean')
+    expect(byField.joined!.type).toBe('dateString')
+  })
+
+  it('marks an `id` field as the read-only primary key', () => {
+    const schema = introspectJson('t', [{ id: 'x', v: 1 }])
+    const id = schema.fields.find((f) => f.field === 'id')!
+    expect(id.primaryKey).toBe(true)
+    expect(id.readonly).toBe(true)
+  })
+})
+
+describe('introspectDrizzle', () => {
+  const source = `
+    import { pgTable, serial, text, integer, boolean, timestamp, jsonb } from 'drizzle-orm/pg-core'
+
+    export const users = pgTable('users', {
+      id: serial('id').primaryKey(),
+      name: text('name').notNull(),
+      age: integer('age'),
+      active: boolean('active').default(false),
+      createdAt: timestamp('created_at').defaultNow(),
+      meta: jsonb('meta'),
+    })
+  `
+
+  it('parses the table name and fields with types', () => {
+    const schema = introspectDrizzle(source)
+    expect(schema.name).toBe('users')
+    const byField = Object.fromEntries(schema.fields.map((f) => [f.field, f]))
+    expect(byField.id!.type).toBe('number')
+    expect(byField.name!.type).toBe('text')
+    expect(byField.age!.type).toBe('number')
+    expect(byField.active!.type).toBe('boolean')
+    expect(byField.createdAt!.type).toBe('datetime')
+    expect(byField.meta!.type).toBe('json')
+  })
+
+  it('reads primaryKey and notNull modifiers', () => {
+    const schema = introspectDrizzle(source)
+    const byField = Object.fromEntries(schema.fields.map((f) => [f.field, f]))
+    expect(byField.id!.primaryKey).toBe(true)
+    expect(byField.id!.readonly).toBe(true)
+    expect(byField.name!.required).toBe(true)
+    expect(byField.age!.required).toBeUndefined()
+  })
+
+  it('works for sqlite/mysql table builders too', () => {
+    const s = introspectDrizzle(`export const t = sqliteTable('todos', { id: integer('id').primaryKey(), title: text('title') })`)
+    expect(s.name).toBe('todos')
+    expect(s.fields.map((f) => f.field)).toEqual(['id', 'title'])
+  })
+
+  it('throws when there is no table definition', () => {
+    expect(() => introspectDrizzle('const x = 1')).toThrow(/no .*Table/)
+  })
+
+  it('reads a composite primary key from the table config (join table)', () => {
+    const s = introspectDrizzle(
+      `
+      export const postsToTags = pgTable('posts_to_tags', {
+        postId: integer('post_id').references(() => posts.id).notNull(),
+        tagId: integer('tag_id').references(() => tags.id).notNull(),
+      }, (t) => ({ pk: primaryKey({ columns: [t.postId, t.tagId] }) }))
+    `,
+      'posts_to_tags',
+    )
+    expect(s.idField).toBe('postId') // first composite member is the key
+    // The other member stays a relation lookup.
+    expect(s.fields.find((f) => f.field === 'tagId')?.type).toBe('relation')
+  })
+
+  it('reads an enum column (pgEnum + inline) as an enum field with options', () => {
+    const s = introspectDrizzle(`
+      export const roleEnum = pgEnum('role', ['admin', 'user'])
+      export const members = pgTable('members', {
+        id: serial('id').primaryKey(),
+        role: roleEnum('role').notNull(),
+        status: text('status', { enum: ['active', 'paused'] }),
+      })
+    `)
+    const byField = Object.fromEntries(s.fields.map((f) => [f.field, f]))
+    expect(byField.role!.type).toBe('enum')
+    expect(byField.role!.options?.map((o) => o.value)).toEqual(['admin', 'user'])
+    expect(byField.status!.type).toBe('enum')
+    expect(byField.status!.options?.map((o) => o.value)).toEqual(['active', 'paused'])
+  })
+
+  it('captures the DB column name when it differs from the property key', () => {
+    const s = introspectDrizzle(`
+      export const users = pgTable('users', {
+        id: serial('id').primaryKey(),
+        createdAt: timestamp('created_at').defaultNow(),
+        name: text('name'),
+      })
+    `)
+    const byField = Object.fromEntries(s.fields.map((f) => [f.field, f]))
+    expect(byField.createdAt!.dbColumn).toBe('created_at') // renamed -> captured
+    expect(byField.name!.dbColumn).toBeUndefined() // same -> omitted
+    expect(byField.id!.dbColumn).toBeUndefined()
+  })
+
+  it('turns a `.references()` column into a relation field', () => {
+    const s = introspectDrizzle(
+      `
+      export const users = pgTable('users', { id: serial('id').primaryKey(), name: text('name') })
+      export const posts = pgTable('posts', {
+        id: serial('id').primaryKey(),
+        authorId: integer('author_id').references(() => users.id).notNull(),
+      })
+    `,
+      'posts',
+    )
+    const author = s.fields.find((f) => f.field === 'authorId')!
+    expect(author.type).toBe('relation')
+    expect(author.relation?.entity).toBe('users')
+    expect(author.required).toBe(true)
+  })
+})
+
+describe('introspectDrizzleAll', () => {
+  const source = `
+    export const users = pgTable('users', {
+      id: serial('id').primaryKey(),
+      name: text('name').notNull(),
+    })
+    export const posts = pgTable('posts', {
+      id: serial('id').primaryKey(),
+      title: text('title').notNull(),
+      authorId: integer('author_id').references(() => users.id),
+    })
+  `
+
+  it('returns every table as a schema', () => {
+    const all = introspectDrizzleAll(source)
+    expect(all.map((s) => s.name)).toEqual(['users', 'posts'])
+  })
+
+  it('links the relation label field from the related table', () => {
+    const posts = introspectDrizzleAll(source).find((s) => s.name === 'posts')!
+    const rel = posts.fields.find((f) => f.field === 'authorId')!
+    expect(rel.type).toBe('relation')
+    expect(rel.relation?.entity).toBe('users')
+    // `users` has a `name` column, so the lookup shows it.
+    expect(rel.relation?.labelField).toBe('name')
+  })
+})