@svgrid/enterprise 2.5.2 → 2.6.0

package/dist/studio/introspect-db.js

@@ -0,0 +1,255 @@
+import { refineField } from '../sources/field-inference.js';
+function truthy(v) {
+    return v === 1 || v === '1' || v === true;
+}
+function identQuote(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/** Dialect-correct identifier quoting for ad-hoc queries (COUNT etc). */
+function quoteIdent(dialect, name) {
+    if (dialect === 'mysql')
+        return `\`${name.replace(/`/g, '``')}\``;
+    if (dialect === 'mssql')
+        return `[${name.replace(/]/g, ']]')}]`;
+    return identQuote(name); // postgres, supabase, sqlite
+}
+/** Best-effort SQL type -> entity field type. The designer can refine edge cases. */
+export function mapSqlType(raw) {
+    const t = raw.toLowerCase();
+    if (/\b(bool|bit)\b/.test(t) || t === 'boolean')
+        return 'boolean';
+    if (/int|serial|numeric|decimal|real|double|float|money|number/.test(t))
+        return 'number';
+    if (/timestamp|datetime/.test(t))
+        return 'datetime';
+    if (/date/.test(t))
+        return 'dateString';
+    if (/json/.test(t))
+        return 'json';
+    return 'text';
+}
+function fieldFrom(name, rawType, pk, notNull) {
+    const field = { field: name, type: mapSqlType(rawType) };
+    if (pk) {
+        field.primaryKey = true;
+        field.readonly = true;
+    }
+    else if (notNull) {
+        field.required = true;
+    }
+    return field;
+}
+/** Map catalog rows (aliased name/type/nullable/pk) from information_schema dialects. */
+function infoSchemaFields(rows) {
+    return rows.map((r) => fieldFrom(String(r.name), String(r.type ?? ''), truthy(r.pk), !truthy(r.nullable)));
+}
+/** Map SQLite `PRAGMA table_info` rows (name/type/notnull/pk-as-index). */
+function sqliteFields(rows) {
+    return rows.map((r) => fieldFrom(String(r.name), String(r.type ?? ''), Number(r.pk) > 0, Number(r.notnull) === 1));
+}
+/** Map information_schema FK rows (aliased column/ref_table/ref_column) - pg / mysql / mssql. */
+function infoSchemaFks(rows) {
+    return rows
+        .filter((r) => r.ref_table)
+        .map((r) => ({ column: String(r.column), table: String(r.ref_table), refColumn: r.ref_column ? String(r.ref_column) : undefined }));
+}
+/** Map SQLite `PRAGMA foreign_key_list` rows (from/table/to). */
+function sqliteFks(rows) {
+    return rows.map((r) => ({ column: String(r.from), table: String(r.table), refColumn: r.to ? String(r.to) : undefined }));
+}
+const POSTGRES = {
+    columns: (table) => ({
+        sql: `SELECT c.column_name AS name, c.data_type AS type,
+       CASE WHEN c.is_nullable = 'YES' THEN 1 ELSE 0 END AS nullable,
+       CASE WHEN pk.column_name IS NOT NULL THEN 1 ELSE 0 END AS pk
+FROM information_schema.columns c
+LEFT JOIN (
+  SELECT kcu.column_name
+  FROM information_schema.table_constraints tc
+  JOIN information_schema.key_column_usage kcu
+    ON kcu.constraint_name = tc.constraint_name AND kcu.table_name = tc.table_name
+  WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_name = $1
+) pk ON pk.column_name = c.column_name
+WHERE c.table_name = $1
+ORDER BY c.ordinal_position`,
+        params: [table],
+    }),
+    toFields: infoSchemaFields,
+    tables: {
+        sql: `SELECT table_name AS name FROM information_schema.tables
+WHERE table_schema = 'public' AND table_type = 'BASE TABLE' ORDER BY table_name`,
+        params: [],
+    },
+    foreignKeys: (table) => ({
+        sql: `SELECT kcu.column_name AS "column", ccu.table_name AS ref_table, ccu.column_name AS ref_column
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON kcu.constraint_name = tc.constraint_name AND kcu.table_name = tc.table_name
+JOIN information_schema.constraint_column_usage ccu
+  ON ccu.constraint_name = tc.constraint_name
+WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = $1`,
+        params: [table],
+    }),
+    toForeignKeys: infoSchemaFks,
+};
+const MYSQL = {
+    columns: (table) => ({
+        sql: `SELECT COLUMN_NAME AS name, DATA_TYPE AS type,
+       CASE WHEN IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS nullable,
+       CASE WHEN COLUMN_KEY = 'PRI' THEN 1 ELSE 0 END AS pk
+FROM information_schema.columns
+WHERE TABLE_NAME = ? AND TABLE_SCHEMA = DATABASE()
+ORDER BY ORDINAL_POSITION`,
+        params: [table],
+    }),
+    toFields: infoSchemaFields,
+    tables: {
+        sql: `SELECT TABLE_NAME AS name FROM information_schema.tables
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME`,
+        params: [],
+    },
+    foreignKeys: (table) => ({
+        sql: `SELECT COLUMN_NAME AS \`column\`, REFERENCED_TABLE_NAME AS ref_table, REFERENCED_COLUMN_NAME AS ref_column
+FROM information_schema.KEY_COLUMN_USAGE
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND REFERENCED_TABLE_NAME IS NOT NULL`,
+        params: [table],
+    }),
+    toForeignKeys: infoSchemaFks,
+};
+const MSSQL = {
+    columns: (table) => ({
+        sql: `SELECT c.COLUMN_NAME AS name, c.DATA_TYPE AS type,
+       CASE WHEN c.IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS nullable,
+       CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS pk
+FROM INFORMATION_SCHEMA.COLUMNS c
+LEFT JOIN (
+  SELECT ku.COLUMN_NAME
+  FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+  JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku ON tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
+  WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY' AND tc.TABLE_NAME = @p1
+) pk ON pk.COLUMN_NAME = c.COLUMN_NAME
+WHERE c.TABLE_NAME = @p1
+ORDER BY c.ORDINAL_POSITION`,
+        params: [table],
+    }),
+    toFields: infoSchemaFields,
+    tables: {
+        sql: `SELECT TABLE_NAME AS name FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME`,
+        params: [],
+    },
+    foreignKeys: (table) => ({
+        sql: `SELECT cu.COLUMN_NAME AS [column], pk.TABLE_NAME AS ref_table, pt.COLUMN_NAME AS ref_column
+FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE cu ON cu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS pk ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE pt
+  ON pt.CONSTRAINT_NAME = pk.CONSTRAINT_NAME AND pt.ORDINAL_POSITION = cu.ORDINAL_POSITION
+WHERE cu.TABLE_NAME = @p1`,
+        params: [table],
+    }),
+    toForeignKeys: infoSchemaFks,
+};
+const SQLITE = {
+    columns: (table) => ({ sql: `PRAGMA table_info(${identQuote(table)})`, params: [] }),
+    toFields: sqliteFields,
+    tables: {
+        sql: `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`,
+        params: [],
+    },
+    foreignKeys: (table) => ({ sql: `PRAGMA foreign_key_list(${identQuote(table)})`, params: [] }),
+    toForeignKeys: sqliteFks,
+};
+const DIALECTS = {
+    postgres: POSTGRES,
+    mysql: MYSQL,
+    mssql: MSSQL,
+    sqlite: SQLITE,
+};
+function defFor(dialect) {
+    const key = dialect === 'supabase' ? 'postgres' : dialect;
+    const def = DIALECTS[key];
+    if (!def)
+        throw new Error(`introspectDatabase: unknown dialect "${dialect}"`);
+    return def;
+}
+/** Convert FK columns into `relation` fields so the form gets a lookup + master-detail is inferable. */
+function applyForeignKeys(fields, fks) {
+    if (fks.length === 0)
+        return fields;
+    const byColumn = new Map(fks.map((fk) => [fk.column, fk]));
+    return fields.map((f) => {
+        const fk = byColumn.get(f.field);
+        if (!fk || f.primaryKey)
+            return f;
+        const rel = {
+            field: f.field,
+            type: 'relation',
+            relation: { entity: fk.table, foreignKey: f.field, labelField: 'name' },
+        };
+        if (f.required)
+            rel.required = true;
+        return rel;
+    });
+}
+/** Read one table's columns (and foreign keys) from the live database into an EntitySchema. */
+export async function introspectDatabase(options) {
+    const def = defFor(options.dialect);
+    const { sql, params } = def.columns(options.table);
+    const rows = await options.execute(sql, params);
+    const fields = def.toFields(rows);
+    if (fields.length === 0) {
+        throw new Error(`introspectDatabase: table "${options.table}" has no columns (does it exist?)`);
+    }
+    // Foreign keys are best-effort: if the catalog query fails (permissions,
+    // unusual setup), degrade to a schema without relations rather than throw.
+    let fks = [];
+    try {
+        const fk = def.foreignKeys(options.table);
+        fks = def.toForeignKeys(await options.execute(fk.sql, fk.params));
+    }
+    catch {
+        fks = [];
+    }
+    // Infer rich editors (phone / email / rating / mask / ...) from column names,
+    // after FK columns became relations so those are left untouched.
+    return { name: options.table, fields: applyForeignKeys(fields, fks).map(refineField) };
+}
+/** List the base tables in the connected database. */
+export async function listDatabaseTables(dialect, execute) {
+    const def = defFor(dialect);
+    const rows = await execute(def.tables.sql, def.tables.params);
+    return rows.map((r) => String(r.name)).filter(Boolean);
+}
+/**
+ * Count rows in each table - powers the designer's "Test connection" step, which
+ * shows the user their real data volumes before they commit to importing. Fully
+ * resilient: a table that can't be counted (permissions, a view) yields
+ * `rows: null` instead of failing the whole probe.
+ */
+export async function countTableRows(dialect, execute, tables) {
+    const out = [];
+    for (const table of tables) {
+        try {
+            const rows = await execute(`SELECT COUNT(*) AS n FROM ${quoteIdent(dialect, table)}`, []);
+            const n = rows[0]?.n;
+            out.push({ name: table, rows: n == null ? null : Number(n) });
+        }
+        catch {
+            out.push({ name: table, rows: null });
+        }
+    }
+    return out;
+}
+/**
+ * One round-trip "test connection": confirm we can talk to the database, list
+ * its tables, and (optionally) report each table's row count. Throws only if the
+ * connection itself is unusable (the caller maps that to a friendly message).
+ */
+export async function probeConnection(dialect, execute, opts = {}) {
+    const names = await listDatabaseTables(dialect, execute);
+    const tables = opts.counts
+        ? await countTableRows(dialect, execute, names)
+        : names.map((name) => ({ name, rows: null }));
+    return { ok: true, tables };
+}

package/dist/studio/introspect-openapi.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { EntitySchema } from '../schema.js';
+import type { EntityDataSource } from './project.js';
+export type OpenApiImport = {
+    entities: EntitySchema[];
+    sources: Record<string, EntityDataSource>;
+    /** Non-fatal notes (skipped paths, unresolved refs) to surface in the UI. */
+    warnings: string[];
+};
+/** Parse + introspect an OpenAPI 3.x JSON document into entities + REST sources. */
+export declare function introspectOpenApi(specText: string): OpenApiImport;

package/dist/studio/introspect-openapi.js

@@ -0,0 +1,244 @@
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+/** Resolve a local `#/components/schemas/Foo` ref (one level). */
+function resolveRef(doc, ref) {
+    const m = ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (!m)
+        return null;
+    return doc.components?.schemas?.[m[1]] ?? null;
+}
+/** Follow a `$ref` to its target schema (guards against a self/cyclic ref). */
+function deref(doc, node, seen = new Set()) {
+    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) {
+    const ref = node?.['$ref'];
+    const m = typeof ref === 'string' ? ref.match(/^#\/components\/schemas\/(.+)$/) : null;
+    return m ? m[1] : null;
+}
+const titleCase = (s) => s.replace(/[-_]+/g, ' ').replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/^./, (c) => c.toUpperCase()).trim();
+const singular = (s) => (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, prop, entityByRef) {
+    // 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, objectSchema, entityByRef) {
+    const props = deref(doc, objectSchema)?.['properties'] ?? {};
+    const required = new Set(deref(doc, objectSchema)?.['required'] ?? []);
+    const fields = [];
+    for (const [name, rawProp] of Object.entries(props)) {
+        const ft = fieldType(doc, rawProp, entityByRef);
+        const isPk = name === 'id' || name === '_id';
+        const field = {
+            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, ops) {
+    const bodySchema = (op, kind) => {
+        if (!op)
+            return null;
+        const content = kind === 'response'
+            ? op['responses']?.['200']?.['content']
+            : op['requestBody']?.['content'];
+        const json = content?.['application/json'];
+        return json?.['schema'] ?? 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']);
+        // wrapped: { data: [ item ] } / { items: [...] } / { results: [...] }
+        for (const key of ['data', 'items', 'results', 'rows']) {
+            const wrapped = deref(doc, s?.['properties']?.[key]);
+            if (wrapped?.['type'] === 'array')
+                return deref(doc, wrapped['items']);
+        }
+    }
+    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) {
+    const content = op?.['responses']?.['200']?.['content'];
+    return content?.['application/json']?.['schema'];
+}
+/** The dotted rows path for a list response ('data'/'items'/...), or undefined
+ *  when the response is a bare array. */
+function rowsPathFor(doc, listOp) {
+    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']?.[key])?.['type'] === 'array')
+            return key;
+    }
+    return undefined;
+}
+function paramsFor(doc, op) {
+    const raw = op?.['parameters'] ?? [];
+    const out = [];
+    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) {
+    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) {
+    let doc;
+    try {
+        doc = JSON.parse(specText);
+    }
+    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 = [];
+    const baseUrl = (doc.servers?.[0]?.url ?? '').replace(/\/+$/, '');
+    const byCollection = new Map();
+    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];
+            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();
+    for (const r of resources) {
+        for (const opKey of ['getOne', 'list', 'create']) {
+            const op = r.ops[opKey];
+            const schema = responseSchema(op) ?? op?.['requestBody']?.['content']?.['application/json']?.['schema'];
+            const direct = refName(schema);
+            if (direct)
+                entityByRef.set(direct, r.name);
+            const arrItem = refName(deref(doc, schema)?.['items']);
+            if (arrItem)
+                entityByRef.set(arrItem, r.name);
+        }
+    }
+    const entities = [];
+    const sources = {};
+    const seenNames = new Set();
+    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 = {
+            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/dist/studio/introspect-prisma.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { type EntitySchema } from '../schema.js';
+/** Parse one Prisma model into an `EntitySchema`. Defaults to the first model. */
+export declare function introspectPrisma(source: string, model?: string): EntitySchema;
+/**
+ * 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 declare function introspectPrismaAll(source: string): EntitySchema[];