@svgrid/enterprise 2.5.2 → 2.6.0

package/src/studio/introspect.test.ts

@@ -1,172 +0,0 @@
-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')
-  })
-})

package/src/studio/introspect.ts

@@ -1,310 +0,0 @@
-/**
- * Introspection - turn a data source into an `EntitySchema`. Entry points:
- *
- *   - `introspectJson(name, rows)` infers fields + types from sample JSON rows.
- *   - `introspectDrizzle(source, table?)` parses one Drizzle table (the string
- *     contents of a `schema.ts`) into an `EntitySchema`, relations and enums
- *     included.
- *   - `introspectDrizzleAll(source)` parses **every** table in the file into a
- *     linked set of schemas (foreign keys become relation fields, so the whole
- *     app scaffolds with working lookups).
- *
- * All are pure and best-effort: the Studio generator (and the AI host) treats
- * the result as a draft the user can refine in `SvSchemaDesigner` before
- * scaffolding code. Nothing imports Drizzle - the reader is a text parse, so
- * there's no dependency and no code execution.
- */
-import { linkRelationLabels, type EntityField, type EntityFieldType, type EntitySchema } from '../schema.js'
-import { buildEntitySchema, type IntrospectedColumn } from '../sources/schema-from-columns.js'
-import { refineFields } from '../sources/field-inference.js'
-
-/** Infer an entity field type from a runtime JSON value. */
-export function inferType(value: unknown): EntityFieldType {
-  if (typeof value === 'boolean') return 'boolean'
-  if (typeof value === 'number') return 'number'
-  if (value !== null && typeof value === 'object') return 'json'
-  if (typeof value === 'string') {
-    if (/^\d{4}-\d{2}-\d{2}T/.test(value)) return 'datetime'
-    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return 'dateString'
-    return 'text'
-  }
-  return 'text'
-}
-
-/** Build a schema from sample rows: union of keys, type from the first non-null value. */
-export function introspectJson(
-  name: string,
-  rows: ReadonlyArray<Record<string, unknown>>,
-): EntitySchema {
-  const keys: string[] = []
-  const seen = new Set<string>()
-  for (const row of rows) {
-    for (const k of Object.keys(row)) {
-      if (!seen.has(k)) {
-        seen.add(k)
-        keys.push(k)
-      }
-    }
-  }
-
-  const fields: EntityField[] = keys.map((k) => {
-    let type: EntityFieldType = 'text'
-    for (const row of rows) {
-      const v = row[k]
-      if (v != null) {
-        type = inferType(v)
-        break
-      }
-    }
-    const field: EntityField = { field: k, type }
-    if (k === 'id') {
-      field.primaryKey = true
-      field.readonly = true
-    }
-    return field
-  })
-
-  return refineFields({ name, fields })
-}
-
-/** Drizzle column builder -> entity field type. */
-const DRIZZLE_TYPE_MAP: Record<string, EntityFieldType> = {
-  serial: 'number',
-  bigserial: 'number',
-  smallserial: 'number',
-  integer: 'number',
-  int: 'number',
-  tinyint: 'number',
-  smallint: 'number',
-  bigint: 'number',
-  numeric: 'number',
-  decimal: 'number',
-  real: 'number',
-  double: 'number',
-  doublePrecision: 'number',
-  float: 'number',
-  boolean: 'boolean',
-  text: 'text',
-  varchar: 'text',
-  char: 'text',
-  uuid: 'text',
-  timestamp: 'datetime',
-  datetime: 'datetime',
-  date: 'dateString',
-  time: 'text',
-  json: 'json',
-  jsonb: 'json',
-}
-
-/** A Drizzle table as found in source: variable name, SQL name, columns body, and extra-config text. */
-type DrizzleTable = { varName: string; name: string; body: string; extras: string }
-
-/** Whole-file context needed to resolve a column: table vars and enum values. */
-type DrizzleContext = {
-  /** Table variable (`export const users = ...`) -> SQL table name. */
-  varToTable: Map<string, string>
-  /** Enum variable (`pgEnum('role', [...])`) -> allowed values. */
-  enums: Map<string, string[]>
-}
-
-/** Read string literals out of a `['a', 'b']`-style array fragment. */
-function stringLiterals(fragment: string): string[] {
-  const out: string[] = []
-  const re = /['"]([^'"]+)['"]/g
-  let m: RegExpExecArray | null
-  while ((m = re.exec(fragment)) !== null) out.push(m[1]!)
-  return out
-}
-
-/** Find the balanced `{ ... }` body starting at (or after) `from`. Returns body + end index. */
-function balancedObject(source: string, from: number): { body: string; end: number } {
-  const open = source.indexOf('{', from)
-  if (open === -1) return { body: '', end: from }
-  let depth = 0
-  for (let i = open; i < source.length; i++) {
-    const ch = source[i]
-    if (ch === '{') depth++
-    else if (ch === '}' && --depth === 0) return { body: source.slice(open + 1, i), end: i }
-  }
-  return { body: '', end: source.length }
-}
-
-/** Split an object body at top-level commas, ignoring commas nested in (), [], {}, or strings. */
-function splitTopLevel(body: string): string[] {
-  const parts: string[] = []
-  let depth = 0
-  let start = 0
-  let str: string | null = null
-  for (let i = 0; i < body.length; i++) {
-    const ch = body[i]
-    if (str) {
-      if (ch === str && body[i - 1] !== '\\') str = null
-      continue
-    }
-    if (ch === "'" || ch === '"' || ch === '`') str = ch
-    else if (ch === '(' || ch === '[' || ch === '{') depth++
-    else if (ch === ')' || ch === ']' || ch === '}') depth--
-    else if (ch === ',' && depth === 0) {
-      parts.push(body.slice(start, i))
-      start = i + 1
-    }
-  }
-  const last = body.slice(start)
-  if (last.trim()) parts.push(last)
-  return parts
-}
-
-/** Locate every `const <var> = xxxTable('name', { ... })` in the source. */
-function findTables(source: string): DrizzleTable[] {
-  const tables: DrizzleTable[] = []
-  const re = /const\s+(\w+)\s*=\s*(\w*[Tt]able)\(\s*['"]([^'"]+)['"]\s*,/g
-  let m: RegExpExecArray | null
-  while ((m = re.exec(source)) !== null) {
-    const { body, end } = balancedObject(source, m.index + m[0].length)
-    if (body) {
-      // Capture the table's second argument (indexes, composite primary key)
-      // by scanning to the matching close paren of the `xxxTable(` call.
-      let depth = 1
-      let str: string | null = null
-      let i = end + 1
-      for (; i < source.length; i++) {
-        const ch = source[i]
-        if (str) {
-          if (ch === str && source[i - 1] !== '\\') str = null
-          continue
-        }
-        if (ch === "'" || ch === '"' || ch === '`') str = ch
-        else if (ch === '(') depth++
-        else if (ch === ')' && --depth === 0) break
-      }
-      tables.push({ varName: m[1]!, name: m[3]!, body, extras: source.slice(end + 1, i) })
-      re.lastIndex = i
-    }
-  }
-  return tables
-}
-
-/** Field names of a Drizzle composite key (`primaryKey({ columns: [t.a, t.b] })`), else empty. */
-function drizzleComposite(extras: string): string[] {
-  const m = extras.match(/primaryKey\(([\s\S]*?)\)/)
-  if (!m) return []
-  return [...m[1]!.matchAll(/\.(\w+)/g)].map((x) => x[1]!)
-}
-
-/** Build the whole-file context (table vars + enum declarations) once. */
-function scanContext(source: string, tables: DrizzleTable[]): DrizzleContext {
-  const varToTable = new Map(tables.map((t) => [t.varName, t.name]))
-  const enums = new Map<string, string[]>()
-  // const roleEnum = pgEnum('role', ['admin', 'user'])   (also mysqlEnum / singlestoreEnum)
-  const re = /const\s+(\w+)\s*=\s*(?:pg|mysql|singlestore)Enum\(\s*['"][^'"]+['"]\s*,\s*\[([^\]]*)\]/g
-  let m: RegExpExecArray | null
-  while ((m = re.exec(source)) !== null) enums.set(m[1]!, stringLiterals(m[2]!))
-  return { varToTable, enums }
-}
-
-/** Parse one column entry (`key: builder(args)<modifiers>`) into a neutral column. */
-function parseColumn(entry: string, ctx: DrizzleContext): IntrospectedColumn | null {
-  const head = entry.match(/^\s*["']?(\w+)["']?\s*:\s*(\w+)\s*\(/)
-  if (!head) return null
-  const name = head[1]!
-  const builder = head[2]!
-  // Balanced args of the builder call, then the trailing modifier chain.
-  const argStart = head.index! + head[0].length - 1
-  let depth = 0
-  let argEnd = argStart
-  for (let i = argStart; i < entry.length; i++) {
-    const ch = entry[i]
-    if (ch === '(') depth++
-    else if (ch === ')' && --depth === 0) {
-      argEnd = i
-      break
-    }
-  }
-  const args = entry.slice(argStart + 1, argEnd)
-  const modifiers = entry.slice(argEnd + 1)
-
-  const col: IntrospectedColumn = { name }
-
-  // Capture the DB column name (the builder's first string arg). When it differs
-  // from the property key, record it so SQL adapters use the real column.
-  const dbColumn = stringLiterals(args)[0]
-  if (dbColumn && dbColumn !== name) col.dbColumn = dbColumn
-
-  // Enum: a `pgEnum` builder var, an inline `mysqlEnum('col', ['a','b'])`, or a
-  // `{ enum: ['a','b'] }` option on a text/varchar column.
-  const inlineEnum = args.match(/enum\s*:\s*\[([^\]]*)\]/)
-  if (ctx.enums.has(builder)) col.enumValues = ctx.enums.get(builder)
-  else if (inlineEnum) col.enumValues = stringLiterals(inlineEnum[1]!)
-  else if (/enum$/i.test(builder)) {
-    const arr = args.match(/\[([^\]]*)\]/)
-    if (arr) col.enumValues = stringLiterals(arr[1]!)
-  }
-  if (!col.enumValues) col.type = DRIZZLE_TYPE_MAP[builder] ?? 'text'
-
-  if (/\.primaryKey\s*\(/.test(modifiers)) col.primaryKey = true
-  if (/\.notNull\s*\(/.test(modifiers)) col.required = true
-
-  // Foreign key: `.references(() => otherTable.col)` -> a relation field.
-  const ref = modifiers.match(/\.references\(\s*\(\)\s*=>\s*(\w+)\.(\w+)/)
-  if (ref) {
-    col.references = { table: ctx.varToTable.get(ref[1]!) ?? ref[1]!, column: ref[2]! }
-  }
-  return col
-}
-
-/** Assemble the neutral column list for one table. */
-function columnsFor(table: DrizzleTable, ctx: DrizzleContext): IntrospectedColumn[] {
-  const columns = splitTopLevel(table.body)
-    .map((entry) => parseColumn(entry, ctx))
-    .filter((c): c is IntrospectedColumn => c !== null)
-
-  // Composite key (`primaryKey({ columns: [t.a, t.b] })` in the table's 2nd arg):
-  // flag the members. buildEntitySchema keys off the first (a join table's screen
-  // targets its first key column).
-  const composite = drizzleComposite(table.extras)
-  if (composite.length && !columns.some((c) => c.primaryKey)) {
-    for (const c of columns) if (composite.includes(c.name)) c.primaryKey = true
-  }
-  return columns
-}
-
-/**
- * Parse one Drizzle table into an `EntitySchema`. Relations (`.references`) and
- * enums (`pgEnum` / inline) are resolved against the whole file. Best-effort and
- * text based: exotic column types fall back to `text`, to be corrected in the
- * designer.
- */
-export function introspectDrizzle(source: string, table?: string): EntitySchema {
-  const tables = findTables(source)
-  if (tables.length === 0) {
-    throw new Error('introspectDrizzle: no `xxxTable("name", { ... })` definition found in source')
-  }
-  const picked = table ? tables.find((t) => t.name === table || t.varName === table) : tables[0]
-  if (!picked) throw new Error(`introspectDrizzle: table "${table}" not found in source`)
-
-  const ctx = scanContext(source, tables)
-  const columns = columnsFor(picked, ctx)
-  if (columns.length === 0) {
-    throw new Error(`introspectDrizzle: parsed table "${picked.name}" but found no fields`)
-  }
-  return buildEntitySchema(picked.name, columns)
-}
-
-/**
- * Parse **every** table in a Drizzle schema file into a linked set of schemas.
- * Foreign keys become relation fields and `linkRelationLabels` resolves each
- * lookup's display field from the actual related table - so the whole app
- * scaffolds with working lookups.
- */
-export function introspectDrizzleAll(source: string): EntitySchema[] {
-  const tables = findTables(source)
-  if (tables.length === 0) {
-    throw new Error('introspectDrizzle: no `xxxTable("name", { ... })` definition found in source')
-  }
-  const ctx = scanContext(source, tables)
-  const schemas = tables
-    .map((t) => ({ t, columns: columnsFor(t, ctx) }))
-    .filter(({ columns }) => columns.length > 0)
-    .map(({ t, columns }) => buildEntitySchema(t.name, columns))
-  return linkRelationLabels(schemas)
-}

package/src/studio/node_modules/.vite/vitest/be65d27ae088a0e03fd8e1331d90b01649464cb6/_svelte_metadata.json

@@ -1 +0,0 @@
-{"compilerOptions":{"css":"external","dev":false,"hmr":false},"extensions":[".svelte"]}

package/src/studio/node_modules/.vite/vitest/be65d27ae088a0e03fd8e1331d90b01649464cb6/deps___vitest__/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/src/studio/pipeline.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { introspectDrizzle } from './introspect'
-import { scaffold } from './scaffold'
-
-/**
- * The end-to-end generator flow the MCP tools expose: a Drizzle schema file
- * becomes an EntitySchema, which becomes runnable SvelteKit files. This proves
- * introspect output feeds scaffold cleanly.
- */
-describe('introspect -> scaffold pipeline', () => {
-  const drizzle = `
-    import { pgTable, serial, text, integer, boolean } from 'drizzle-orm/pg-core'
-    export const products = pgTable('products', {
-      id: serial('id').primaryKey(),
-      title: text('title').notNull(),
-      price: integer('price'),
-      inStock: boolean('in_stock').default(true),
-    })
-  `
-
-  it('drizzle source -> schema -> scaffolded files', () => {
-    const schema = introspectDrizzle(drizzle)
-    const { files } = scaffold(schema)
-    const byPath = Object.fromEntries(files.map((f) => [f.path, f]))
-
-    // schema module reflects the parsed table + fields
-    const schemaFile = byPath['src/lib/products.schema.ts']!.contents
-    expect(schemaFile).toContain('export const productsSchema: EntitySchema<ProductsRow>')
-    expect(schemaFile).toContain('title: string')
-    expect(schemaFile).toContain('price: number')
-    expect(schemaFile).toContain('inStock: boolean')
-    expect(schemaFile).toContain('field: "id", type: "number", primaryKey: true, readonly: true')
-
-    // page + server route are wired to the products endpoint
-    expect(byPath['src/routes/products/+page.svelte']!.contents).toContain(
-      "createKitDataSource<ProductsRow>({ endpoint: '/api/products' })",
-    )
-    expect(byPath['src/routes/api/products/+server.ts']!.contents).toContain(
-      'createKitHandlers({ schema: productsSchema, source })',
-    )
-  })
-})