@jigx/sdk-tools 1.2.0-next.2 → 1.2.0-next.4

package/dist/migrator/converters/assets.js

@@ -0,0 +1,58 @@
+import { isPlainObject } from '../normalize.js';
+import { countNodes } from '../report.js';
+import { lit, str } from '../ts-printer.js';
+const UNSUPPORTED = {
+    type: 'skip',
+    gapId: 'assets:unsupported-shape',
+    reason: 'only images, icons and theme.palette assets have typed calls',
+};
+function isStringList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function listArgs(values) {
+    return values.map((value) => `    ${str(value)},\n`).join('');
+}
+function convertValue(options) {
+    const { id, value } = options;
+    if (id === 'images' && isStringList(value) && value.length > 0) {
+        return {
+            code: `app.images(\n${listArgs(value)}  )`,
+            run: (app) => {
+                app.images(...value);
+            },
+        };
+    }
+    if (id === 'icons' && isStringList(value) && value.length > 0) {
+        return {
+            code: `app.icons(\n${listArgs(value)}  )`,
+            run: (app) => {
+                app.icons(...value);
+            },
+        };
+    }
+    if (id === 'theme' &&
+        isPlainObject(value) &&
+        Object.keys(value).length === 1 &&
+        'palette' in value &&
+        countNodes({ value: value.palette, asRoot: false }) === 0) {
+        const palette = value.palette;
+        return {
+            code: `app.themePalette(${lit(palette, '  ')})`,
+            run: (app) => {
+                app.themePalette(palette);
+            },
+        };
+    }
+    return undefined;
+}
+/**
+ * `assets/<id>.jigx` (`{ <id>: value }`) → `app.images(…)`, `app.icons(…)` or `app.themePalette(…)`.
+ */
+export function convertAsset(entry) {
+    const { id, entity } = entry;
+    if (!isPlainObject(entity) || Object.keys(entity).length !== 1 || !(id in entity))
+        return UNSUPPORTED;
+    const statement = convertValue({ id, value: entity[id] });
+    return statement ? { type: 'statements', statements: [statement] } : UNSUPPORTED;
+}
+//# sourceMappingURL=assets.js.map

package/dist/migrator/converters/assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../../src/migrator/converters/assets.ts"],"names":[],"mappings":"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"}

package/dist/migrator/converters/components.d.ts

@@ -0,0 +1,4 @@
+import { type EntityConverter } from './types.js';
+/** Custom component definitions have no core-sdk builder: an entity-level gap. */
+export declare const convertComponent: EntityConverter;
+//# sourceMappingURL=components.d.ts.map

package/dist/migrator/converters/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../src/migrator/converters/components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,EAAE,eAI7B,CAAA"}

package/dist/migrator/converters/components.js

@@ -0,0 +1,7 @@
+/** Custom component definitions have no core-sdk builder: an entity-level gap. */
+export const convertComponent = () => ({
+    type: 'skip',
+    gapId: 'components:definition-builder',
+    reason: 'core-sdk has no builder for custom component definitions',
+});
+//# sourceMappingURL=components.js.map

package/dist/migrator/converters/components.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.js","sourceRoot":"","sources":["../../../src/migrator/converters/components.ts"],"names":[],"mappings":"AAEA,kFAAkF;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAAoB,GAAG,EAAE,CAAC,CAAC;IACtD,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,+BAA+B;IACtC,MAAM,EAAE,0DAA0D;CACnE,CAAC,CAAA"}

package/dist/migrator/converters/databases.d.ts

@@ -0,0 +1,9 @@
+import { type LegacyEntry } from '../read-solution.js';
+import { type EntityConversion } from './types.js';
+/**
+ * `databases/default.jigx` → `app.addDatabase.default.table(...)`.
+ *
+ * Only the `default` database with `null` table definitions has a typed builder.
+ */
+export declare function convertDatabase(entry: LegacyEntry): EntityConversion;
+//# sourceMappingURL=databases.d.ts.map

package/dist/migrator/converters/databases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databases.d.ts","sourceRoot":"","sources":["../../../src/migrator/converters/databases.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEtD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,gBAAgB,CAoCpE"}

package/dist/migrator/converters/databases.js

@@ -0,0 +1,45 @@
+import { isPlainObject } from '../normalize.js';
+import { str } from '../ts-printer.js';
+/**
+ * `databases/default.jigx` → `app.addDatabase.default.table(...)`.
+ *
+ * Only the `default` database with `null` table definitions has a typed builder.
+ */
+export function convertDatabase(entry) {
+    const { id, entity } = entry;
+    if (id !== 'default' || !isPlainObject(entity)) {
+        return {
+            type: 'skip',
+            gapId: 'databases:unsupported-shape',
+            reason: 'only the default database is typed',
+        };
+    }
+    const { databaseId, tables, ...rest } = entity;
+    const extraKeys = Object.keys(rest);
+    const idMatches = databaseId === undefined || databaseId === id;
+    const tablesTyped = tables === undefined ||
+        (isPlainObject(tables) && Object.values(tables).every((t) => t === null));
+    if (extraKeys.length > 0 || !idMatches || !tablesTyped) {
+        return {
+            type: 'skip',
+            gapId: 'databases:unsupported-shape',
+            reason: 'database keys other than null tables have no typed builder',
+        };
+    }
+    const names = isPlainObject(tables) ? Object.keys(tables) : [];
+    if (names.length === 0)
+        return { type: 'statements', statements: [] };
+    const args = names.map((name) => `    ${str(name)},\n`).join('');
+    return {
+        type: 'statements',
+        statements: [
+            {
+                code: `app.addDatabase.default.table(\n${args}  )`,
+                run: (app) => {
+                    app.addDatabase.default.table(...names);
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=databases.js.map

package/dist/migrator/converters/databases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"databases.js","sourceRoot":"","sources":["../../../src/migrator/converters/databases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAGtC;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,KAAkB;IAChD,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,CAAA;IAC5B,IAAI,EAAE,KAAK,SAAS,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QAC/C,OAAO;YACL,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,6BAA6B;YACpC,MAAM,EAAE,oCAAoC;SAC7C,CAAA;IACH,CAAC;IACD,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAA;IAC9C,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACnC,MAAM,SAAS,GAAG,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,EAAE,CAAA;IAC/D,MAAM,WAAW,GACf,MAAM,KAAK,SAAS;QACpB,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAA;IAC3E,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,WAAW,EAAE,CAAC;QACvD,OAAO;YACL,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,6BAA6B;YACpC,MAAM,EAAE,4DAA4D;SACrE,CAAA;IACH,CAAC;IACD,MAAM,KAAK,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;IAC9D,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,EAAE,CAAA;IACrE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAChE,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,UAAU,EAAE;YACV;gBACE,IAAI,EAAE,mCAAmC,IAAI,KAAK;gBAClD,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE;oBACX,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;gBACzC,CAAC;aACF;SACF;KACF,CAAA;AACH,CAAC"}

package/dist/migrator/converters/datasources.d.ts

@@ -0,0 +1,46 @@
+import { type LegacyEntry } from '../read-solution.js';
+import { type NodePathSegment } from '../report.js';
+import { type EntityConversion } from './types.js';
+/** Where a datasource is declared: `datasources/<id>.jigx` or a jig's `datasources` map. */
+export type DatasourceScope = 'app' | 'screen';
+/** A key skipped inside a verified datasource; `path` is relative to the datasource. */
+interface DatasourceGap {
+    /** Reason slug: the gap id is `datasources:<slug>` or `jig:datasource-<slug>`. */
+    readonly slug: string;
+    readonly reason: string;
+    readonly skippedNodes: number;
+    readonly path: readonly NodePathSegment[];
+}
+export type DatasourceConversion = {
+    readonly type: 'skip';
+    readonly slug: string;
+    readonly reason: string;
+} | {
+    readonly type: 'typed';
+    /** The `<parentExpr>.addDatasource.<factory>(…)` statement at the register-body indent. */
+    readonly code: (parentExpr: string) => string;
+    /** Replays the verified calls on an `ApplicationBuilder` or a screen builder. */
+    readonly attach: (host: unknown) => void;
+    readonly gaps: readonly DatasourceGap[];
+};
+/**
+ * Converts one legacy datasource into a typed `addDatasource.<factory>(…)` call chain.
+ *
+ * - `datasource.sqlite` (local or dynamic): `entity`/`entityPackaged`, `parameter`,
+ *   `queryParameter`, `rewriteQuery`, `isDocument`, `jsonProperties`, `query`
+ * - `datasource.static`: `data` in the factory input
+ * - `datasource.reference` (screen scope only): `descriptor` plus `param` per input
+ *
+ * Optional keys and options that do not verify are skipped one by one (`key-<key>`,
+ * `option-<key>`); the whole datasource is then verified against the pruned legacy.
+ * A datasource with no typed constructor, or whose required parts do not verify, is skipped.
+ */
+export declare function convertDatasourceDefinition(options: {
+    readonly key: string;
+    readonly legacy: unknown;
+    readonly scope: DatasourceScope;
+}): DatasourceConversion;
+/** `datasources/<id>.jigx` → `app.addDatasource.<factory>(…)`; gaps are `datasources:<slug>`. */
+export declare function convertDatasource(entry: LegacyEntry): EntityConversion;
+export {};
+//# sourceMappingURL=datasources.d.ts.map

package/dist/migrator/converters/datasources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasources.d.ts","sourceRoot":"","sources":["../../../src/migrator/converters/datasources.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AAE/D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,4FAA4F;AAC5F,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,CAAA;AAE9C,wFAAwF;AACxF,UAAU,aAAa;IACrB,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,eAAe,EAAE,CAAA;CAC1C;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACzE;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAA;IAC7C,iFAAiF;IACjF,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,CAAA;CACxC,CAAA;AA6bL;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;CAChC,GAAG,oBAAoB,CAmBvB;AAED,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,gBAAgB,CAwBtE"}

package/dist/migrator/converters/datasources.js

@@ -0,0 +1,445 @@
+import { isDeepStrictEqual } from 'node:util';
+import { ApplicationBuilder, DATA_PROVIDER, DATASOURCE_TYPE, DatasourceReferenceBuilder, isPrimitiveOrExpression, ParameterValueSchema, ScreenBaseBuilderNew, SqliteDatasourceBuilder, StaticDatasourceBuilder, } from '@jigx/core-sdk';
+import { firstLine, messageSlug, toJsonValue } from '../nodes/index.js';
+import { dropUndefined, isPlainObject, normalizeEntity } from '../normalize.js';
+import { pruneAt } from '../prune.js';
+import { countNodes } from '../report.js';
+import { lit, str } from '../ts-printer.js';
+const INDENT = '  ';
+const CHAIN_INDENT = `${INDENT}  `;
+const SQLITE_KEYS = [
+    'type',
+    'options',
+    'parameters',
+    'datasourceId',
+    'instanceId',
+];
+const SQLITE_PROVIDERS = {
+    [DATA_PROVIDER.LOCAL]: 'local',
+    [DATA_PROVIDER.DYNAMIC]: 'dynamic',
+};
+function skipped(slug, reason) {
+    return { type: 'skip', slug, reason };
+}
+function comparable(value) {
+    return dropUndefined(toJsonValue(value));
+}
+function buildWith(factory, steps) {
+    try {
+        const builder = factory.create();
+        for (const step of steps)
+            step.apply(builder);
+        const built = toJsonValue(builder.build());
+        return { type: 'built', value: isPlainObject(built) ? built : {} };
+    }
+    catch (error) {
+        return { type: 'error', message: firstLine(error) };
+    }
+}
+function application(host) {
+    if (host instanceof ApplicationBuilder || host instanceof ScreenBaseBuilderNew)
+        return host;
+    throw new Error('A datasource host must be an ApplicationBuilder or a screen builder');
+}
+function screen(host) {
+    if (host instanceof ScreenBaseBuilderNew)
+        return host;
+    throw new Error('A datasource reference needs a screen builder');
+}
+function primitiveRecord(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const out = {};
+    for (const [name, item] of Object.entries(value)) {
+        if (!isPrimitiveOrExpression(item))
+            return undefined;
+        out[name] = item;
+    }
+    return out;
+}
+function isInlineData(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => item === null ||
+            typeof item === 'string' ||
+            typeof item === 'number' ||
+            typeof item === 'boolean' ||
+            isPlainObject(item)));
+}
+/** Typed `.entity(…)`/`.entityPackaged(…)` call for one legacy sqlite entity. */
+function entityStep(entity) {
+    if (typeof entity === 'string') {
+        return {
+            code: `entity(${str(entity)})`,
+            apply: (builder) => {
+                builder.entity(entity);
+            },
+        };
+    }
+    if (!isPlainObject(entity) || typeof entity.entity !== 'string')
+        return undefined;
+    const name = entity.entity;
+    const keys = Object.keys(entity);
+    if (keys.length === 2 && typeof entity.package === 'string') {
+        const packageName = entity.package;
+        return {
+            code: `entityPackaged(${str(name)}, ${str(packageName)})`,
+            apply: (builder) => {
+                builder.entityPackaged(name, packageName);
+            },
+        };
+    }
+    if (!keys.every((key) => ['entity', 'function', 'functionParameters'].includes(key))) {
+        return undefined;
+    }
+    const fn = entity.function;
+    if (fn !== undefined && typeof fn !== 'string')
+        return undefined;
+    const params = entity.functionParameters === undefined ? undefined : primitiveRecord(entity.functionParameters);
+    if (entity.functionParameters !== undefined && params === undefined)
+        return undefined;
+    const input = {
+        entity: name,
+        ...(fn === undefined ? {} : { fn }),
+        ...(params === undefined ? {} : { params }),
+    };
+    return {
+        code: `entity(${lit(input, CHAIN_INDENT)})`,
+        apply: (builder) => {
+            builder.entity(structuredClone(input));
+        },
+    };
+}
+/** Typed sqlite calls for one optional legacy option; `undefined` when it has none. */
+function optionSteps(key, value) {
+    if (key === 'queryParameters') {
+        const params = primitiveRecord(value);
+        if (!params || Object.keys(params).length === 0)
+            return undefined;
+        return Object.entries(params).map(([name, item]) => ({
+            code: `queryParameter(${str(name)}, ${lit(item, CHAIN_INDENT)})`,
+            apply: (builder) => {
+                builder.queryParameter(name, item);
+            },
+        }));
+    }
+    if ((key === 'rewriteQuery' || key === 'isDocument') && typeof value === 'boolean') {
+        return [
+            {
+                code: `${key}(${String(value)})`,
+                apply: (builder) => {
+                    if (key === 'rewriteQuery')
+                        builder.rewriteQuery(value);
+                    else
+                        builder.isDocument(value);
+                },
+            },
+        ];
+    }
+    if (key === 'jsonProperties' &&
+        Array.isArray(value) &&
+        value.every((item) => typeof item === 'string')) {
+        const columns = value;
+        return [
+            {
+                code: `jsonProperties(${columns.map((column) => str(column)).join(', ')})`,
+                apply: (builder) => {
+                    builder.jsonProperties(...columns);
+                },
+            },
+        ];
+    }
+    return undefined;
+}
+function parameterDefault(value) {
+    const parsed = ParameterValueSchema.safeParse(value);
+    return parsed.success ? parsed.data : undefined;
+}
+/** Typed `.parameter(…)` calls for the legacy `parameters` map; `undefined` when one has none. */
+function parameterSteps(value) {
+    if (!isPlainObject(value) || Object.keys(value).length === 0)
+        return undefined;
+    const steps = [];
+    for (const [name, parameter] of Object.entries(value)) {
+        if (!isPlainObject(parameter) || typeof parameter.type !== 'string')
+            return undefined;
+        if (!Object.keys(parameter).every((key) => ['type', 'required', 'default'].includes(key))) {
+            return undefined;
+        }
+        const { type, required } = parameter;
+        if (required !== undefined && typeof required !== 'boolean')
+            return undefined;
+        const defaultValue = parameterDefault(parameter.default);
+        if (parameter.default !== undefined && defaultValue === undefined)
+            return undefined;
+        const options = {
+            ...(required === undefined ? {} : { required }),
+            ...(defaultValue === undefined ? {} : { defaultValue }),
+        };
+        const hasOptions = Object.keys(options).length > 0;
+        steps.push({
+            code: `parameter(${str(name)}, ${str(type)}${hasOptions ? `, ${lit(options, CHAIN_INDENT)}` : ''})`,
+            apply: (builder) => {
+                builder.parameter(name, type, hasOptions ? structuredClone(options) : undefined);
+            },
+        });
+    }
+    return steps;
+}
+/** Verifies the whole datasource against the pruned legacy and returns the typed conversion. */
+function finish(options) {
+    const { key, legacy, factory, steps, gaps } = options;
+    const whole = buildWith(factory, steps);
+    if (whole.type === 'error') {
+        return skipped(`throws-${messageSlug(whole.message)}`, `the typed datasource throws: ${whole.message}`);
+    }
+    const pruned = pruneAt({ value: legacy, path: [], gaps });
+    const equal = isDeepStrictEqual(normalizeEntity({ kind: 'datasources', id: key, entity: whole.value }), normalizeEntity({ kind: 'datasources', id: key, entity: comparable(pruned) }));
+    if (!equal) {
+        return skipped('output-differs', 'the typed datasource does not reproduce the legacy datasource');
+    }
+    return {
+        type: 'typed',
+        gaps,
+        code: (parentExpr) => `${parentExpr}.addDatasource.${factory.name}(${lit(factory.input, INDENT)})${steps
+            .map((step) => `\n${CHAIN_INDENT}.${step.code}`)
+            .join('')}`,
+        attach: (host) => {
+            const builder = factory.createOn(host);
+            for (const step of steps)
+                step.apply(builder);
+        },
+    };
+}
+function keyGap(key, value, reason) {
+    return {
+        slug: `key-${key}`,
+        reason,
+        skippedNodes: countNodes({ value, asRoot: false }),
+        path: [key],
+    };
+}
+function optionGap(key, value, reason) {
+    return {
+        slug: `option-${key}`,
+        reason,
+        skippedNodes: countNodes({ value, asRoot: false }),
+        path: ['options', key],
+    };
+}
+function convertSqlite(key, legacy) {
+    const { options, instanceId } = legacy;
+    if (!isPlainObject(options))
+        return skipped('shape', 'sqlite options must be a mapping');
+    const provider = typeof options.provider === 'string' ? SQLITE_PROVIDERS[options.provider] : undefined;
+    if (!provider)
+        return skipped('option-provider', 'only local and dynamic sqlite providers are typed');
+    const gaps = [];
+    for (const [name, value] of Object.entries(legacy)) {
+        if (!SQLITE_KEYS.includes(name))
+            gaps.push(keyGap(name, value, `no typed sqlite call for "${name}"`));
+    }
+    if (instanceId !== undefined && typeof instanceId !== 'string') {
+        gaps.push(keyGap('instanceId', instanceId, 'instanceId is not a string'));
+    }
+    const input = {
+        datasourceId: key,
+        provider,
+        ...(typeof instanceId === 'string' && instanceId !== key ? { instanceId } : {}),
+    };
+    const factory = {
+        name: 'sqlite',
+        input,
+        create: () => new SqliteDatasourceBuilder(structuredClone(input)),
+        createOn: (host) => application(host).addDatasource.sqlite(structuredClone(input)),
+    };
+    const entities = Array.isArray(options.entities) ? options.entities : [];
+    const entitySteps = entities.map((entity) => entityStep(entity));
+    if (!Array.isArray(options.entities) || entitySteps.some((step) => step === undefined)) {
+        return skipped('option-entities', 'an entity has no typed .entity() form');
+    }
+    const { query } = options;
+    if (typeof query !== 'string' || query.trim() === '') {
+        return skipped('option-query', 'the query is not a non-empty string');
+    }
+    const queryStep = {
+        code: `query(${lit(query, CHAIN_INDENT)})`,
+        apply: (builder) => {
+            builder.query(query);
+        },
+    };
+    const head = entitySteps.filter((step) => step !== undefined);
+    try {
+        const builder = factory.create();
+        for (const step of head)
+            step.apply(builder);
+    }
+    catch (error) {
+        return skipped('option-entities', `.entity() throws: ${firstLine(error)}`);
+    }
+    const base = buildWith(factory, [...head, queryStep]);
+    if (base.type === 'error') {
+        return skipped('option-query', `the typed datasource does not build: ${base.message}`);
+    }
+    const builtOptions = isPlainObject(base.value.options) ? base.value.options : {};
+    for (const name of ['provider', 'entities', 'query']) {
+        if (!isDeepStrictEqual(comparable(builtOptions[name]), comparable(options[name]))) {
+            return skipped(`option-${name}`, `the typed calls do not reproduce "${name}"`);
+        }
+    }
+    const middle = [];
+    const verifies = (candidate, read, legacyValue) => {
+        const result = buildWith(factory, [...head, ...candidate, queryStep]);
+        return (result.type === 'built' &&
+            isDeepStrictEqual(comparable(read(result.value)), comparable(legacyValue)));
+    };
+    if (legacy.parameters !== undefined) {
+        const steps = parameterSteps(legacy.parameters);
+        if (steps && verifies(steps, (built) => built.parameters, legacy.parameters)) {
+            middle.push(...steps);
+        }
+        else {
+            gaps.push(keyGap('parameters', legacy.parameters, 'no typed .parameter() calls reproduce "parameters"'));
+        }
+    }
+    for (const [name, value] of Object.entries(options)) {
+        if (name === 'provider' || name === 'entities' || name === 'query')
+            continue;
+        const steps = optionSteps(name, value);
+        const read = (built) => isPlainObject(built.options) ? built.options[name] : undefined;
+        if (steps && verifies(steps, read, value))
+            middle.push(...steps);
+        else
+            gaps.push(optionGap(name, value, `no typed sqlite call reproduces "${name}"`));
+    }
+    return finish({ key, legacy, factory, steps: [...head, ...middle, queryStep], gaps });
+}
+function convertStatic(key, legacy) {
+    const { options } = legacy;
+    if (!isPlainObject(options))
+        return skipped('shape', 'static options must be a mapping');
+    const gaps = [];
+    for (const [name, value] of Object.entries(legacy)) {
+        if (!['type', 'options', 'datasourceId', 'instanceId'].includes(name)) {
+            gaps.push(keyGap(name, value, `no typed static datasource input for "${name}"`));
+        }
+    }
+    if (legacy.instanceId !== undefined && legacy.instanceId !== key) {
+        gaps.push(keyGap('instanceId', legacy.instanceId, 'the static datasource input has no instanceId'));
+    }
+    for (const [name, value] of Object.entries(options)) {
+        if (name !== 'data')
+            gaps.push(optionGap(name, value, `no typed static datasource input for "${name}"`));
+    }
+    const { data } = options;
+    if (!isInlineData(data))
+        return skipped('option-data', 'data is not a list of values or objects');
+    const input = { datasourceId: key, data };
+    const factory = {
+        name: 'static',
+        input,
+        create: () => new StaticDatasourceBuilder(structuredClone(input)),
+        createOn: (host) => application(host).addDatasource.static(structuredClone(input)),
+    };
+    return finish({ key, legacy, factory, steps: [], gaps });
+}
+function convertReference(key, legacy) {
+    const { datasourceId, inputs } = legacy;
+    if (typeof datasourceId !== 'string')
+        return skipped('key-datasourceId', 'a reference needs a datasourceId');
+    const packageName = typeof legacy.package === 'string' ? legacy.package : undefined;
+    const gaps = [];
+    for (const [name, value] of Object.entries(legacy)) {
+        if (['type', 'datasourceId', 'inputs'].includes(name))
+            continue;
+        if (name === 'package' && packageName !== undefined)
+            continue;
+        if (name === 'instanceId' && value === key)
+            continue;
+        gaps.push(keyGap(name, value, `no typed reference input for "${name}"`));
+    }
+    const steps = [];
+    if (inputs !== undefined) {
+        const params = primitiveRecord(inputs);
+        if (params && Object.keys(params).length > 0) {
+            for (const [name, value] of Object.entries(params)) {
+                steps.push({
+                    code: `param(${str(name)}, ${lit(value, CHAIN_INDENT)})`,
+                    apply: (builder) => {
+                        builder.param(name, value);
+                    },
+                });
+            }
+        }
+        else {
+            gaps.push(keyGap('inputs', inputs, 'no typed .param() calls reproduce "inputs"'));
+        }
+    }
+    const input = {
+        instanceId: key,
+        descriptor: { datasourceId, ...(packageName === undefined ? {} : { packageName }) },
+    };
+    const factory = {
+        name: 'reference',
+        input,
+        create: () => new DatasourceReferenceBuilder(structuredClone(input)),
+        createOn: (host) => screen(host).addDatasource.reference(structuredClone(input)),
+    };
+    return finish({ key, legacy, factory, steps, gaps });
+}
+/**
+ * Converts one legacy datasource into a typed `addDatasource.<factory>(…)` call chain.
+ *
+ * - `datasource.sqlite` (local or dynamic): `entity`/`entityPackaged`, `parameter`,
+ *   `queryParameter`, `rewriteQuery`, `isDocument`, `jsonProperties`, `query`
+ * - `datasource.static`: `data` in the factory input
+ * - `datasource.reference` (screen scope only): `descriptor` plus `param` per input
+ *
+ * Optional keys and options that do not verify are skipped one by one (`key-<key>`,
+ * `option-<key>`); the whole datasource is then verified against the pruned legacy.
+ * A datasource with no typed constructor, or whose required parts do not verify, is skipped.
+ */
+export function convertDatasourceDefinition(options) {
+    const { key, legacy, scope } = options;
+    if (!isPlainObject(legacy))
+        return skipped('shape', 'a datasource must be a YAML mapping');
+    if (legacy.datasourceId !== undefined &&
+        legacy.datasourceId !== key &&
+        legacy.type !== DATASOURCE_TYPE.REFERENCE) {
+        return skipped('key-datasourceId', 'datasourceId differs from its key');
+    }
+    if (legacy.type === DATASOURCE_TYPE.SQLITE)
+        return convertSqlite(key, legacy);
+    if (legacy.type === DATASOURCE_TYPE.STATIC)
+        return convertStatic(key, legacy);
+    if (legacy.type === DATASOURCE_TYPE.REFERENCE && scope === 'screen') {
+        return convertReference(key, legacy);
+    }
+    return skipped(`type-${messageSlug(String(legacy.type))}`, `no typed ${scope === 'app' ? 'app.addDatasource' : 'screen.addDatasource'} factory for ${String(legacy.type)}`);
+}
+/** `datasources/<id>.jigx` → `app.addDatasource.<factory>(…)`; gaps are `datasources:<slug>`. */
+export function convertDatasource(entry) {
+    const { id, entity } = entry;
+    const result = convertDatasourceDefinition({ key: id, legacy: entity, scope: 'app' });
+    if (result.type === 'skip') {
+        return { type: 'skip', gapId: `datasources:${result.slug}`, reason: result.reason };
+    }
+    return {
+        type: 'statements',
+        gaps: result.gaps.map(({ slug, reason, skippedNodes, path }) => ({
+            gapId: `datasources:${slug}`,
+            nodeType: 'datasources',
+            reason,
+            skippedNodes,
+            path,
+        })),
+        statements: [
+            {
+                code: result.code('app'),
+                run: (app) => {
+                    result.attach(app);
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=datasources.js.map