@svgrid/enterprise 2.5.3 → 2.6.0

package/dist/studio/introspect-prisma.js

@@ -0,0 +1,164 @@
+/**
+ * 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 } from '../schema.js';
+import { buildEntitySchema } from '../sources/schema-from-columns.js';
+/** Prisma scalar type -> entity field type. Unknown scalars fall back to text. */
+const PRISMA_TYPE_MAP = {
+    Int: 'number',
+    BigInt: 'number',
+    Float: 'number',
+    Decimal: 'number',
+    String: 'text',
+    Boolean: 'boolean',
+    DateTime: 'datetime',
+    Json: 'json',
+    Bytes: 'text',
+};
+/** Find each `model X { ... }` / `enum X { ... }` block and return its inner body. */
+function blocks(source, keyword) {
+    const out = [];
+    const re = new RegExp(`${keyword}\\s+(\\w+)\\s*\\{`, 'g');
+    let m;
+    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) {
+    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) {
+    return lines(body)
+        .map((l) => l.match(/^(\w+)/)?.[1])
+        .filter((v) => Boolean(v));
+}
+/** Collect `@relation(fields: [fk], references: [ref])` FKs declared in a model. */
+function relationsOf(modelLines) {
+    const rels = 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) {
+    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, modelNames, enums) {
+    const modelLines = lines(model.body);
+    const relations = relationsOf(modelLines);
+    const columns = [];
+    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 = { 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) {
+    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, model) {
+    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) {
+    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/dist/studio/introspect.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { type EntityFieldType, type EntitySchema } from '../schema.js';
+/** Infer an entity field type from a runtime JSON value. */
+export declare function inferType(value: unknown): EntityFieldType;
+/** Build a schema from sample rows: union of keys, type from the first non-null value. */
+export declare function introspectJson(name: string, rows: ReadonlyArray<Record<string, unknown>>): EntitySchema;
+/**
+ * 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 declare function introspectDrizzle(source: string, table?: string): EntitySchema;
+/**
+ * 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 declare function introspectDrizzleAll(source: string): EntitySchema[];

package/dist/studio/introspect.js

@@ -0,0 +1,306 @@
+/**
+ * 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 } from '../schema.js';
+import { buildEntitySchema } 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) {
+    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, rows) {
+    const keys = [];
+    const seen = new Set();
+    for (const row of rows) {
+        for (const k of Object.keys(row)) {
+            if (!seen.has(k)) {
+                seen.add(k);
+                keys.push(k);
+            }
+        }
+    }
+    const fields = keys.map((k) => {
+        let type = 'text';
+        for (const row of rows) {
+            const v = row[k];
+            if (v != null) {
+                type = inferType(v);
+                break;
+            }
+        }
+        const field = { 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 = {
+    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',
+};
+/** Read string literals out of a `['a', 'b']`-style array fragment. */
+function stringLiterals(fragment) {
+    const out = [];
+    const re = /['"]([^'"]+)['"]/g;
+    let m;
+    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, from) {
+    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) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    let str = 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) {
+    const tables = [];
+    const re = /const\s+(\w+)\s*=\s*(\w*[Tt]able)\(\s*['"]([^'"]+)['"]\s*,/g;
+    let m;
+    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 = 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) {
+    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, tables) {
+    const varToTable = new Map(tables.map((t) => [t.varName, t.name]));
+    const enums = new Map();
+    // 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;
+    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, ctx) {
+    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 = { 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, ctx) {
+    const columns = splitTopLevel(table.body)
+        .map((entry) => parseColumn(entry, ctx))
+        .filter((c) => 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, table) {
+    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) {
+    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);
+}