@jigx/core-sdk 1.0.0

package/dist/datasource/datasource.reference.js

@@ -0,0 +1,66 @@
+import { z } from 'zod/v4';
+import { DATASOURCE_TYPE, DatasourceIdSchema, PrimitiveOrExpressionSchema, toInstanceId, } from '../abstract/index.js';
+const ReferenceDatasourceSchema = z.object({
+    type: z.literal(DATASOURCE_TYPE.REFERENCE),
+    datasourceId: DatasourceIdSchema,
+    inputs: z.record(z.string(), PrimitiveOrExpressionSchema).optional(),
+    package: z.string().optional(),
+});
+export class DatasourceReferenceBuilder {
+    _descriptor;
+    _instanceId;
+    _inputs = {};
+    constructor(options) {
+        this._descriptor = options.descriptor;
+        this._instanceId = toInstanceId(options.instanceId);
+    }
+    get instanceId() {
+        return this._instanceId;
+    }
+    get descriptor() {
+        return this._descriptor;
+    }
+    get schema() {
+        return this._descriptor.schema;
+    }
+    param(key, value) {
+        this._inputs[key] = value;
+        return this;
+    }
+    build() {
+        const result = {
+            type: DATASOURCE_TYPE.REFERENCE,
+            datasourceId: this._descriptor.datasourceId,
+        };
+        if (this._descriptor.packageName) {
+            result.package = this._descriptor.packageName;
+        }
+        if (Object.keys(this._inputs).length > 0) {
+            result.inputs = { ...this._inputs };
+        }
+        return result;
+    }
+    _validate() {
+        if (!this._descriptor.inputDefinitions) {
+            return { valid: true, issues: [] };
+        }
+        const names = Object.keys(this._descriptor.inputDefinitions);
+        if (names.length === 0) {
+            return { valid: true, issues: [] };
+        }
+        let isValid = true;
+        const issues = [];
+        for (const name of names) {
+            const definition = this._descriptor.inputDefinitions[name];
+            const value = this._inputs[name];
+            if (definition.required && (typeof value === 'undefined' || value === null)) {
+                isValid = false;
+                issues.push({
+                    message: `Input parameter "${name}" is required but not provided.`,
+                });
+            }
+        }
+        return { valid: isValid, issues };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource/datasource.sdk.d.ts

@@ -0,0 +1,7 @@
+import { DatasourceReferenceBuilder, type ReferenceDatasource } from './datasource.reference.js';
+import { type SqliteDatasource, SqliteDatasourceBuilder } from './datasource.sqlite.js';
+import { type StaticDatasource, StaticDatasourceBuilder } from './datasource.static.js';
+import { type SystemDatasource, SystemDatasourceBuilder } from './datasource.system.js';
+export type Datasource = SqliteDatasource | StaticDatasource | SystemDatasource | ReferenceDatasource;
+export type DatasourceBuilder = SqliteDatasourceBuilder | StaticDatasourceBuilder | SystemDatasourceBuilder | DatasourceReferenceBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5zZGsuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYXRhc291cmNlL2RhdGFzb3VyY2Uuc2RrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxLQUFLLG1CQUFtQixFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFDaEcsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUN2RixPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHdCQUF3QixDQUFBO0FBQ3ZGLE9BQU8sRUFBRSxLQUFLLGdCQUFnQixFQUFFLHVCQUF1QixFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFFdkYsTUFBTSxNQUFNLFVBQVUsR0FDbEIsZ0JBQWdCLEdBQ2hCLGdCQUFnQixHQUNoQixnQkFBZ0IsR0FDaEIsbUJBQW1CLENBQUE7QUFFdkIsTUFBTSxNQUFNLGlCQUFpQixHQUN6Qix1QkFBdUIsR0FDdkIsdUJBQXVCLEdBQ3ZCLHVCQUF1QixHQUN2QiwwQkFBMEIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGFzb3VyY2VSZWZlcmVuY2VCdWlsZGVyLCB0eXBlIFJlZmVyZW5jZURhdGFzb3VyY2UgfSBmcm9tICcuL2RhdGFzb3VyY2UucmVmZXJlbmNlLmpzJ1xuaW1wb3J0IHsgdHlwZSBTcWxpdGVEYXRhc291cmNlLCBTcWxpdGVEYXRhc291cmNlQnVpbGRlciB9IGZyb20gJy4vZGF0YXNvdXJjZS5zcWxpdGUuanMnXG5pbXBvcnQgeyB0eXBlIFN0YXRpY0RhdGFzb3VyY2UsIFN0YXRpY0RhdGFzb3VyY2VCdWlsZGVyIH0gZnJvbSAnLi9kYXRhc291cmNlLnN0YXRpYy5qcydcbmltcG9ydCB7IHR5cGUgU3lzdGVtRGF0YXNvdXJjZSwgU3lzdGVtRGF0YXNvdXJjZUJ1aWxkZXIgfSBmcm9tICcuL2RhdGFzb3VyY2Uuc3lzdGVtLmpzJ1xuXG5leHBvcnQgdHlwZSBEYXRhc291cmNlID1cbiAgfCBTcWxpdGVEYXRhc291cmNlXG4gIHwgU3RhdGljRGF0YXNvdXJjZVxuICB8IFN5c3RlbURhdGFzb3VyY2VcbiAgfCBSZWZlcmVuY2VEYXRhc291cmNlXG5cbmV4cG9ydCB0eXBlIERhdGFzb3VyY2VCdWlsZGVyID1cbiAgfCBTcWxpdGVEYXRhc291cmNlQnVpbGRlclxuICB8IFN0YXRpY0RhdGFzb3VyY2VCdWlsZGVyXG4gIHwgU3lzdGVtRGF0YXNvdXJjZUJ1aWxkZXJcbiAgfCBEYXRhc291cmNlUmVmZXJlbmNlQnVpbGRlclxuIl19

package/dist/datasource/datasource.sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.sdk.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.sdk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,KAAK,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAChG,OAAO,EAAE,KAAK,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAA;AACvF,OAAO,EAAE,KAAK,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAA;AACvF,OAAO,EAAE,KAAK,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAA;AAEvF,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,CAAA;AAEvB,MAAM,MAAM,iBAAiB,GACzB,uBAAuB,GACvB,uBAAuB,GACvB,uBAAuB,GACvB,0BAA0B,CAAA","sourcesContent":["import { DatasourceReferenceBuilder, type ReferenceDatasource } from './datasource.reference.js'\nimport { type SqliteDatasource, SqliteDatasourceBuilder } from './datasource.sqlite.js'\nimport { type StaticDatasource, StaticDatasourceBuilder } from './datasource.static.js'\nimport { type SystemDatasource, SystemDatasourceBuilder } from './datasource.system.js'\n\nexport type Datasource =\n  | SqliteDatasource\n  | StaticDatasource\n  | SystemDatasource\n  | ReferenceDatasource\n\nexport type DatasourceBuilder =\n  | SqliteDatasourceBuilder\n  | StaticDatasourceBuilder\n  | SystemDatasourceBuilder\n  | DatasourceReferenceBuilder\n"]}

package/dist/datasource/datasource.sdk.js

@@ -0,0 +1,5 @@
+import './datasource.reference.js';
+import './datasource.sqlite.js';
+import './datasource.static.js';
+import './datasource.system.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5zZGsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YXNvdXJjZS9kYXRhc291cmNlLnNkay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFxRSwyQkFBMkIsQ0FBQTtBQUNoRyxPQUErRCx3QkFBd0IsQ0FBQTtBQUN2RixPQUErRCx3QkFBd0IsQ0FBQTtBQUN2RixPQUErRCx3QkFBd0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGFzb3VyY2VSZWZlcmVuY2VCdWlsZGVyLCB0eXBlIFJlZmVyZW5jZURhdGFzb3VyY2UgfSBmcm9tICcuL2RhdGFzb3VyY2UucmVmZXJlbmNlLmpzJ1xuaW1wb3J0IHsgdHlwZSBTcWxpdGVEYXRhc291cmNlLCBTcWxpdGVEYXRhc291cmNlQnVpbGRlciB9IGZyb20gJy4vZGF0YXNvdXJjZS5zcWxpdGUuanMnXG5pbXBvcnQgeyB0eXBlIFN0YXRpY0RhdGFzb3VyY2UsIFN0YXRpY0RhdGFzb3VyY2VCdWlsZGVyIH0gZnJvbSAnLi9kYXRhc291cmNlLnN0YXRpYy5qcydcbmltcG9ydCB7IHR5cGUgU3lzdGVtRGF0YXNvdXJjZSwgU3lzdGVtRGF0YXNvdXJjZUJ1aWxkZXIgfSBmcm9tICcuL2RhdGFzb3VyY2Uuc3lzdGVtLmpzJ1xuXG5leHBvcnQgdHlwZSBEYXRhc291cmNlID1cbiAgfCBTcWxpdGVEYXRhc291cmNlXG4gIHwgU3RhdGljRGF0YXNvdXJjZVxuICB8IFN5c3RlbURhdGFzb3VyY2VcbiAgfCBSZWZlcmVuY2VEYXRhc291cmNlXG5cbmV4cG9ydCB0eXBlIERhdGFzb3VyY2VCdWlsZGVyID1cbiAgfCBTcWxpdGVEYXRhc291cmNlQnVpbGRlclxuICB8IFN0YXRpY0RhdGFzb3VyY2VCdWlsZGVyXG4gIHwgU3lzdGVtRGF0YXNvdXJjZUJ1aWxkZXJcbiAgfCBEYXRhc291cmNlUmVmZXJlbmNlQnVpbGRlclxuIl19

package/dist/datasource/datasource.sqlite.d.ts

@@ -0,0 +1,88 @@
+import { type ConversionDefinition, DATA_PROVIDER, DATASOURCE_TYPE, type DatasourceId, type EntityName, type Expression, type FunctionId, type InstanceId, type ParameterName, type ParameterValue, type Primitive, type PrimitiveOrExpression, type TableName } from '../abstract/index.js';
+import { type FunctionCore } from '../function/index.js';
+import { type DatasourceBase, DatasourceBaseBuilder } from './datasource.abstract.js';
+export type SqliteParamExpressions = Record<ParameterName, PrimitiveOrExpression>;
+interface SqliteDatasourceEntity {
+    entity: string;
+    package?: string;
+    function?: string;
+    functionParameters?: SqliteParamExpressions;
+}
+export type SqliteProviderType = typeof DATA_PROVIDER.DYNAMIC | typeof DATA_PROVIDER.LOCAL;
+interface SqliteDatasourceOptions {
+    provider: SqliteProviderType;
+    entities: Array<SqliteDatasourceEntity | string>;
+    query: string;
+    queryParameters?: SqliteParamExpressions;
+    isDocument?: boolean;
+    rewriteQuery?: boolean;
+    jsonProperties?: string[] | null;
+    conversions?: ConversionDefinition[];
+}
+export type SqliteDatasource = DatasourceBase & {
+    readonly type: typeof DATASOURCE_TYPE.SQLITE;
+    readonly options: SqliteDatasourceOptions;
+    parameters?: Record<ParameterName, {
+        readonly type: string;
+        readonly default?: ParameterValue;
+        readonly required?: boolean;
+    }>;
+};
+export interface SqliteDatasourceInput {
+    readonly datasourceId: string | DatasourceId;
+    readonly provider: 'dynamic' | 'local';
+    readonly instanceId?: InstanceId;
+}
+export declare class SqliteDatasourceBuilder extends DatasourceBaseBuilder<SqliteDatasource> {
+    private readonly _requiredTables;
+    private _explicitQuery;
+    private _lastFromClause;
+    constructor(options: SqliteDatasourceInput);
+    private validateParameterName;
+    private applyDefaultQuery;
+    getRequiredTables(): readonly string[];
+    private registerDynamicTable;
+    private resolveFunctionId;
+    query(sql: string): this;
+    entity(input: string | TableName | {
+        entity: string | TableName;
+        fn?: FunctionId | FunctionCore;
+        params?: SqliteParamExpressions;
+    }): this;
+    entityPackaged(name: string | TableName, packageName: string): this;
+    param(name: string | ParameterName, type: string, value: Primitive | Expression, options?: {
+        required?: boolean;
+        defaultValue?: Primitive | Expression;
+    }): this;
+    queryParameter(name: string | ParameterName, value: string | number | boolean | null | PrimitiveOrExpression): this;
+    parameter(name: string | ParameterName, type: string, options?: {
+        required?: boolean;
+        defaultValue?: ParameterValue;
+    }): this;
+    rewriteQuery(value?: boolean): this;
+    isDocument(value?: boolean): this;
+    jsonProperties(...columns: string[]): this;
+    select(columns: string | string[], from: string | TableName | EntityName, where?: string, options?: {
+        tableAlias?: string;
+    }): this;
+    selectDocument(from: string | TableName | EntityName, options?: {
+        where?: string;
+        tableAlias?: string;
+    }): this;
+    jsonExtract(column: string, options?: {
+        path?: string;
+        alias?: string;
+        tableAlias?: string;
+    }): this;
+    entities(...names: Array<string | TableName | EntityName>): this;
+    convert(property: string, from: 'buffer' | 'local-uri' | 'base64' | 'data-uri', to: 'buffer' | 'base64' | 'data-uri', options?: {
+        convertHeicToJpg?: boolean;
+    }): this;
+    convert(property: string, from: 'buffer' | 'local-uri' | 'base64' | 'data-uri', to: 'local-uri', options?: {
+        localFilename?: string;
+        convertHeicToJpg?: boolean;
+    }): this;
+    build(): SqliteDatasource;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datasource.sqlite.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.sqlite.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type ConversionDefinition,\n  DATA_PROVIDER,\n  DATASOURCE_TYPE,\n  type DatasourceId,\n  type EntityName,\n  type Expression,\n  type FunctionId,\n  type InstanceId,\n  isFunctionId,\n  type ParameterName,\n  ParameterNameSchema,\n  type ParameterValue,\n  type Primitive,\n  type PrimitiveOrExpression,\n  type TableName,\n  toDatabaseTableName,\n  toDatasourceId,\n  toEntityName,\n  toFunctionId,\n  toParameterName,\n} from '../abstract/index.js'\nimport { type FunctionCore, isFunctionCore } from '../function/index.js'\nimport { type DatasourceBase, DatasourceBaseBuilder } from './datasource.abstract.js'\nimport {\n  createValidationDatabase,\n  replaceParameters,\n  replaceTableName,\n  validateSelectQuery,\n} from './sqlite-validator.js'\n\n/**\n * SQLite parameter expressions map.\n */\nexport type SqliteParamExpressions = Record<ParameterName, PrimitiveOrExpression>\n\n/**\n * SQLite datasource entity configuration.\n */\ninterface SqliteDatasourceEntity {\n  entity: string\n  package?: string\n  function?: string\n  functionParameters?: SqliteParamExpressions\n}\n\n/**\n * SQLite datasource provider types.\n */\nexport type SqliteProviderType = typeof DATA_PROVIDER.DYNAMIC | typeof DATA_PROVIDER.LOCAL\n\n/**\n * SQLite datasource options.\n */\ninterface SqliteDatasourceOptions {\n  provider: SqliteProviderType\n  entities: Array<SqliteDatasourceEntity | string>\n  query: string\n  queryParameters?: SqliteParamExpressions\n  isDocument?: boolean\n  rewriteQuery?: boolean\n  jsonProperties?: string[] | null\n  conversions?: ConversionDefinition[]\n}\n\n/**\n * SQLite datasource definition.\n */\nexport type SqliteDatasource = DatasourceBase & {\n  readonly type: typeof DATASOURCE_TYPE.SQLITE\n  readonly options: SqliteDatasourceOptions\n  parameters?: Record<\n    ParameterName,\n    {\n      readonly type: string\n      readonly default?: ParameterValue\n      readonly required?: boolean\n    }\n  >\n}\n\n/**\n * ---\n * SqliteDatasourceBuilder Parameter Convention\n *\n * - .parameter(name, type, required?, defaultValue?)\n *   - Defines a *formal* parameter (name, type, required, default)\n *   - Like a function signature or API contract\n *   - Example:\n *     builder.parameter('userId', 'string', 'required')\n *     builder.parameter('limit', 'number', 'optional', 10)\n *\n * - .queryParameter(name, value)\n *   - Sets the *runtime value* for a parameter (constant or JSONata expression)\n *   - Like passing an argument to a function call\n *   - Example:\n *     builder.queryParameter('userId', '=@ctx.user.id')\n *     builder.queryParameter('limit', 25)\n *\n * - .param(name)\n *   - Fluent helper for setting query parameter values\n *   - Example:\n *     builder.param('userId').value(123)\n *\n * | Method              | Purpose                        | Example                                      |\n * |---------------------|--------------------------------|----------------------------------------------|\n * | .parameter()        | Define parameter (name/type)   | .parameter('userId', 'string', 'required')   |\n * | .queryParameter()   | Set value for parameter        | .queryParameter('userId', 123)               |\n * | .param()            | Fluent value setter (helper)   | .param('userId').value(123)                  |\n *\n * ---\n */\n\n/**\n * Query local SQLite database.\n *\n * Primary datasource for screens. Data stored locally as JSON.\n * Use json_extract() for field access.\n * Providers: dynamic (cloud sync) or local (device-only).\n * Parameters: $paramName in queries.\n * Sync data using sync-entities actions triggered on onLoad/onFocus/onRefresh events.\n *\n * @alias datasource.sqlite\n */\nexport interface SqliteDatasourceInput {\n  readonly datasourceId: string | DatasourceId\n  readonly provider: 'dynamic' | 'local'\n  readonly instanceId?: InstanceId\n}\n\nexport class SqliteDatasourceBuilder extends DatasourceBaseBuilder<SqliteDatasource> {\n  private readonly _requiredTables: string[] = []\n  private _explicitQuery = false\n  private _lastFromClause: string | undefined\n\n  /**\n   * Create SQLite datasource builder.\n   *\n   * @param options - Configuration options\n   * @param options.datasourceId - Unique identifier. Format: Mixedcase 2-50, prefer kebab-case, starts alpha, contains alphanum and `-`, ends alphanum\n   * @param options.provider - 'dynamic' (cloud-sync) or 'local' (device-only)\n   * @param options.instanceId - Optional instance ID (defaults to datasourceId)\n   */\n  constructor(options: SqliteDatasourceInput) {\n    const { datasourceId, provider, instanceId } = options\n    super(DATASOURCE_TYPE.SQLITE, {\n      datasourceId: toDatasourceId(datasourceId),\n      instanceId,\n    })\n\n    this._config.provider = provider === 'local' ? DATA_PROVIDER.LOCAL : DATA_PROVIDER.DYNAMIC\n    this._config.query = ''\n    this._config.entities = []\n  }\n\n  /**\n   * Validate and normalize parameter names.\n   */\n  private validateParameterName(name: string | ParameterName): string | ParameterName {\n    if (typeof name === 'string') {\n      // Remove @ prefix if present (common mistake)\n      if (name.startsWith('@')) {\n        name = name.slice(1)\n      }\n      // First try to validate as-is (ParameterNameSchema allows both $ and alpha start)\n      const result = ParameterNameSchema.safeParse(name)\n      if (result.success) {\n        return result.data\n      } else {\n        // If validation fails, use toParameterDollar which will give proper error message\n        return toParameterName(name)\n      }\n    }\n    return name\n  }\n\n  private applyDefaultQuery(fromClause: string): void {\n    if (this._explicitQuery) return\n    this._lastFromClause = fromClause\n    if (this._config.isDocument) {\n      this._config.query = `SELECT tbl.id, tbl.data\n                                     FROM ${fromClause} AS tbl`\n    } else {\n      this._config.query = `SELECT tbl.id, json_extract(tbl.data, '$.name') AS name\n                                     FROM ${fromClause} AS tbl`\n    }\n  }\n\n  /**\n   * Table names that need registration on the default database.\n   * Collected during entity() calls for dynamic-provider datasources.\n   *\n   * Note: Tables are only auto-registered when this datasource is built\n   * through ApplicationBuilder. Standalone usage requires manual table\n   * registration on the DatabaseBuilder.\n   */\n  getRequiredTables(): readonly string[] {\n    return this._requiredTables\n  }\n\n  private registerDynamicTable(entityName: string): void {\n    if (this._config.provider !== DATA_PROVIDER.DYNAMIC) return\n    this._requiredTables.push(toDatabaseTableName(entityName))\n  }\n\n  private resolveFunctionId(fn: FunctionId | FunctionCore): FunctionId {\n    if (isFunctionCore(fn)) return fn.functionId\n    if (isFunctionId(fn)) return fn\n    return toFunctionId(fn)\n  }\n\n  /**\n   * Set SQL query. Use json_extract() for JSON data.\n   * Style: UPPER keywords, [table] AS alias, $params.\n   * Include id first. Add tables via entity().\n   * Use MCP to access SQLite cheatsheet.\n   *\n   * @param sql - SQL query with json_extract() and $parameters\n   * @returns Builder for chaining\n   */\n  query(sql: string): this {\n    if (!sql || sql.trim() === '') {\n      throw new Error('Query cannot be empty or whitespace')\n    }\n    this._config.query = sql\n    this._explicitQuery = true\n    return this\n  }\n\n  /**\n   * Add entity (table) to sync/query.\n   * - String form: `entity('default/users')` → `'default/users'`\n   * - Object form: `entity({ entity: 'users' })` → `{ entity: 'users' }`\n   * - Function form: `entity({ entity: 'users', fn, params? })` → `{ entity: 'users', function: '...', ... }`\n   *\n   * @param input - Entity name or descriptor\n   * @returns Builder for chaining\n   */\n  entity(\n    input:\n      | string\n      | TableName\n      | {\n          entity: string | TableName\n          fn?: FunctionId | FunctionCore\n          params?: SqliteParamExpressions\n        },\n  ): this {\n    const entities = this._config.entities as Array<SqliteDatasourceEntity | string>\n\n    if (typeof input === 'string') {\n      const resolved = toEntityName(input, this._config.provider === DATA_PROVIDER.DYNAMIC)\n      this.registerDynamicTable(resolved)\n      entities.push(resolved)\n      this.applyDefaultQuery(`[${resolved}]`)\n    } else {\n      const resolved = toEntityName(input.entity, this._config.provider === DATA_PROVIDER.DYNAMIC)\n      this.registerDynamicTable(resolved)\n      if (input.fn) {\n        entities.push({\n          entity: resolved,\n          function: this.resolveFunctionId(input.fn),\n          functionParameters: input.params,\n        })\n      } else {\n        entities.push({ entity: resolved })\n      }\n      this.applyDefaultQuery(`[${resolved}]`)\n    }\n    return this\n  }\n\n  /**\n   * Add entity from an external package.\n   *\n   * @param name - Entity/table name\n   * @param packageName - Package name\n   * @returns Builder for chaining\n   * @example entityPackaged('Customers', 'erp')\n   */\n  entityPackaged(name: string | TableName, packageName: string): this {\n    const entities = this._config.entities as Array<SqliteDatasourceEntity | string>\n    entities.push({ entity: name, package: packageName })\n    this.applyDefaultQuery(`[${packageName}].[${name}]`)\n    return this\n  }\n\n  /**\n   * Define parameter and set value in one call.\n   * Combines parameter() and queryParameter().\n   *\n   * @param name - Parameter name (no $ prefix)\n   * @param type - Type (string, number, boolean)\n   * @param value - Runtime value or expression\n   * @param options - Required/default settings\n   * @returns Builder for chaining\n   */\n  param(\n    name: string | ParameterName,\n    type: string,\n    value: Primitive | Expression,\n    options?: {\n      required?: boolean\n      defaultValue?: Primitive | Expression\n    },\n  ): this {\n    this.parameter(name, type, {\n      required: options?.required,\n      defaultValue: options?.defaultValue,\n    })\n    this.queryParameter(name, value)\n\n    return this\n  }\n\n  /**\n   * Set runtime value for SQL parameter. Reference as $name in query.\n   * Supports static values and expressions.\n   *\n   * @param name - Parameter name (without $ prefix)\n   * @param value - Value or expression (=@ctx.*, =@ctx.jig.inputs.*)\n   * @returns This builder for chaining\n   */\n  queryParameter(\n    name: string | ParameterName,\n    value: string | number | boolean | null | PrimitiveOrExpression,\n  ): this {\n    const validatedName = this.validateParameterName(name)\n\n    if (!this._config.queryParameters) {\n      this._config.queryParameters = {}\n    }\n    ;(this._config.queryParameters as SqliteParamExpressions)[validatedName] = value\n    return this\n  }\n\n  /**\n   * Define formal parameter (like function signature).\n   * Use queryParameter() to set runtime values.\n   *\n   * @param name - Parameter name\n   * @param type - Type (string, number, boolean)\n   * @param options - Required/default settings\n   * @returns This builder for chaining\n   */\n  parameter(\n    name: string | ParameterName,\n    type: string,\n    options?: { required?: boolean; defaultValue?: ParameterValue },\n  ): this {\n    const validatedName = this.validateParameterName(name)\n\n    if (!this._config.parameters) {\n      this._config.parameters = {}\n    }\n\n    ;(this._config.parameters as NonNullable<SqliteDatasource['parameters']>)[validatedName] = {\n      type,\n      required: options?.required,\n      default: options?.defaultValue,\n    }\n\n    return this\n  }\n\n  /**\n   * Enable or disable query rewriting for shorthand syntax.\n   * When true, $.propertyName is rewritten to json_extract(data, '$.propertyName').\n   * Defaults to true.\n   *\n   * @param value - true to enable rewriting\n   * @returns This builder for chaining\n   */\n  rewriteQuery(value = true): this {\n    this._config.rewriteQuery = value\n    return this\n  }\n\n  /**\n   * Return single document instead of array. Query should return full data column.\n   * Use for detail views, single record lookups.\n   *\n   * @param value - true for document mode (default: true)\n   * @returns This builder for chaining\n   */\n  isDocument(value = true): this {\n    this._config.isDocument = value\n    if (this._lastFromClause) {\n      this.applyDefaultQuery(this._lastFromClause)\n    }\n    return this\n  }\n\n  /**\n   * Parse columns as JSON in query results.\n   * Use when storing JSON strings that need parsing.\n   *\n   * @param columns - Column names to parse\n   * @returns This builder for chaining\n   */\n  jsonProperties(...columns: string[]): this {\n    if (!this._config.jsonProperties) {\n      this._config.jsonProperties = []\n    }\n    ;(this._config.jsonProperties as string[]).push(...columns)\n    return this\n  }\n\n  /**\n   * Helper: Build SELECT query with json_extract columns.\n   * Automatically add entity and format query.\n   *\n   * @param columns - Columns to extract from data JSON\n   * @param from - Table name\n   * @param where - WHERE clause (can use $params)\n   * @param options - Table alias option\n   * @returns This builder for chaining\n   */\n  select(\n    columns: string | string[],\n    from: string | TableName | EntityName,\n    where?: string,\n    options?: { tableAlias?: string },\n  ): this {\n    this.isDocument(false)\n\n    from = toEntityName(from, this._config.provider === DATA_PROVIDER.DYNAMIC)\n    this.entity(from)\n\n    const tableAlias = options?.tableAlias || 'tbl'\n    const cols = Array.isArray(columns) ? columns : columns.split(',').map((c) => c.trim())\n    // Always ensure id is first, and not duplicated in json_extract\n    const selectCols = [`${tableAlias}.id`]\n    for (const col of cols) {\n      if (col !== 'id') {\n        selectCols.push(`json_extract(${tableAlias}.data, '$.${col}') AS ${col}`)\n      }\n    }\n    let query = `SELECT ${selectCols.join(', ')}\n                 FROM [${from}] AS ${tableAlias}`\n    if (where) query += ` WHERE ${where}`\n    this.query(query)\n    return this\n  }\n\n  /**\n   * Helper: Build document query (returns full data object).\n   * Set isDocument(true) and create appropriate query.\n   *\n   * @param from - Table name\n   * @param options - WHERE clause and alias options\n   * @returns This builder for chaining\n   */\n  selectDocument(\n    from: string | TableName | EntityName,\n    options?: { where?: string; tableAlias?: string },\n  ): this {\n    this.isDocument(true)\n\n    from = toEntityName(from, this._config.provider === DATA_PROVIDER.DYNAMIC)\n    this.entity(from)\n\n    const tableAlias = options?.tableAlias || 'tbl'\n    let query = `SELECT ${tableAlias}.id, ${tableAlias}.data\n                 FROM [${from}] AS ${tableAlias}`\n    if (options?.where) query += ` WHERE ${options.where}`\n    this.query(query)\n\n    return this\n  }\n\n  /**\n   * Helper: Add json_extract column to existing query.\n   * Modify current SELECT clause.\n   *\n   * @param column - Column name to extract\n   * @param options - Path, alias, and table options\n   * @returns This builder for chaining\n   */\n  jsonExtract(\n    column: string,\n    options?: { path?: string; alias?: string; tableAlias?: string },\n  ): this {\n    const tableAlias: string = options?.tableAlias || 'tbl'\n    const columnAlias: string = options?.alias || column\n\n    // We don't need to extract the id column, it is already directly in query\n    if (column === 'id') return this\n\n    let path: string = options?.path || column\n    if (!path.startsWith('$')) path = `$.${path}`\n\n    const currentQuery = this._config.query as string\n    if (currentQuery.includes('SELECT')) {\n      // Replace or append to select clause\n      const newColumn = `json_extract(${tableAlias}.data, '${path}') AS ${columnAlias}`\n      const modifiedQuery = currentQuery.replace(/SELECT\\s+/, `SELECT ${newColumn}, `)\n      this.query(modifiedQuery)\n    }\n    return this\n  }\n\n  /**\n   * Add multiple entities at once.\n   * Shorthand for multiple entity() calls.\n   *\n   * @param names - Entity/table names\n   * @returns This builder for chaining\n   */\n  entities(...names: Array<string | TableName | EntityName>): this {\n    names.forEach((name) => this.entity(name))\n    return this\n  }\n\n  /**\n   * Convert data between formats (images, files).\n   * Common: BASE64 → LOCAL_URI for displaying images.\n   *\n   * @param property - Property path to convert\n   * @param from - Source format\n   * @param to - Target format\n   * @param options - Optional localFilename for local-uri target, convertHeicToJpg flag\n   * @returns This builder for chaining\n   */\n  convert(\n    property: string,\n    from: 'buffer' | 'local-uri' | 'base64' | 'data-uri',\n    to: 'buffer' | 'base64' | 'data-uri',\n    options?: { convertHeicToJpg?: boolean },\n  ): this\n\n  convert(\n    property: string,\n    from: 'buffer' | 'local-uri' | 'base64' | 'data-uri',\n    to: 'local-uri',\n    options?: { localFilename?: string; convertHeicToJpg?: boolean },\n  ): this\n\n  convert(\n    property: string,\n    from: 'buffer' | 'local-uri' | 'base64' | 'data-uri',\n    to: 'buffer' | 'base64' | 'data-uri' | 'local-uri',\n    options?: { localFilename?: string; convertHeicToJpg?: boolean },\n  ): this {\n    if (!this._config.conversions) {\n      this._config.conversions = []\n    }\n\n    let conversion: ConversionDefinition\n    if (to === 'local-uri') {\n      conversion = options?.localFilename\n        ? { property, from, to, localFilename: options.localFilename }\n        : { property, from, to }\n    } else {\n      conversion = { property, from, to }\n    }\n    if (options?.convertHeicToJpg !== undefined) {\n      conversion.convertHeicToJpg = options.convertHeicToJpg\n    }\n\n    ;(this._config.conversions as ConversionDefinition[]).push(conversion)\n    return this\n  }\n\n  /**\n   * Build and return SQLite datasource definition.\n   * @returns Complete SQLite datasource configuration\n   */\n  override build(): SqliteDatasource {\n    const query = this._config.query as string\n    const entities = this._config.entities as Array<SqliteDatasourceEntity | string>\n    const provider = this._config.provider as SqliteProviderType\n\n    // Validate that we have a non-empty query\n    if (!query || query.trim() === '') {\n      throw new Error('Query cannot be empty or whitespace')\n    }\n\n    // Extract table names from entities (including package prefix for external packages)\n    const tableNames = entities.map((entity) => {\n      if (typeof entity === 'string') return entity\n      // For package entities, use the full [package].[table] format that appears in queries\n      if (entity.package) {\n        return `[${entity.package}].[${entity.entity}]`\n      }\n      return entity.entity\n    })\n\n    // Create in-memory database with all tables for validation\n    const { db, tables } = createValidationDatabase(tableNames)\n\n    // Working copy for validation\n    let validationQuery = query\n\n    try {\n      // Apply all table name transformations to query\n      tables.forEach(({ safeName, normalizedName }) => {\n        if (safeName !== normalizedName) {\n          validationQuery = replaceTableName(validationQuery, normalizedName, safeName)\n        }\n      })\n\n      // Replace named parameters with positional placeholders for validation\n      validationQuery = replaceParameters(validationQuery)\n\n      // Validate query syntax and ensure it's a SELECT\n      validateSelectQuery(db, validationQuery)\n\n      // Assemble the output\n      const options: SqliteDatasourceOptions = {\n        provider,\n        entities,\n        query,\n      }\n\n      if (this._config.queryParameters) {\n        options.queryParameters = this._config.queryParameters as SqliteParamExpressions\n      }\n      if (this._config.isDocument !== undefined) {\n        options.isDocument = this._config.isDocument as boolean\n      }\n      if (this._config.rewriteQuery !== undefined) {\n        options.rewriteQuery = this._config.rewriteQuery as boolean\n      }\n      if (this._config.jsonProperties) {\n        options.jsonProperties = this._config.jsonProperties as string[]\n      }\n      if (this._config.conversions) {\n        options.conversions = this._config.conversions as ConversionDefinition[]\n      }\n\n      const result: SqliteDatasource = {\n        type: DATASOURCE_TYPE.SQLITE,\n        datasourceId: this.datasourceId,\n        instanceId: this.instanceId,\n        options,\n      }\n\n      if (this._config.parameters) {\n        result.parameters = this._config.parameters as NonNullable<SqliteDatasource['parameters']>\n      }\n\n      return result\n    } catch (error) {\n      // Provide helpful error message with original query (not transformed validation query)\n      const errorMsg = error instanceof Error ? error.message : String(error)\n      throw new Error(`Invalid SQL query: ${errorMsg}\\n\\nQuery: ${query}`)\n    } finally {\n      // Always close the database\n      db.close()\n    }\n  }\n}\n"]}

package/dist/datasource/datasource.sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.sqlite.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.sqlite.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type ConversionDefinition,\n  DATA_PROVIDER,\n  DATASOURCE_TYPE,\n  type DatasourceId,\n  type EntityName,\n  type Expression,\n  type FunctionId,\n  type InstanceId,\n  isFunctionId,\n  type ParameterName,\n  ParameterNameSchema,\n  type ParameterValue,\n  type Primitive,\n  type PrimitiveOrExpression,\n  type TableName,\n  toDatabaseTableName,\n  toDatasourceId,\n  toEntityName,\n  toFunctionId,\n  toParameterName,\n} from '../abstract/index.js'\nimport { type FunctionCore, isFunctionCore } from '../function/index.js'\nimport { type DatasourceBase, DatasourceBaseBuilder } from './datasource.abstract.js'\nimport {\n  createValidationDatabase,\n  replaceParameters,\n  replaceTableName,\n  validateSelectQuery,\n} from './sqlite-validator.js'\n\n/**\n * SQLite parameter expressions map.\n */\nexport type SqliteParamExpressions = Record<ParameterName, PrimitiveOrExpression>\n\n/**\n * SQLite datasource entity configuration.\n */\ninterface SqliteDatasourceEntity {\n  entity: string\n  package?: string\n  function?: string\n  functionParameters?: SqliteParamExpressions\n}\n\n/**\n * SQLite datasource provider types.\n */\nexport type SqliteProviderType = typeof DATA_PROVIDER.DYNAMIC | typeof DATA_PROVIDER.LOCAL\n\n/**\n * SQLite datasource options.\n */\ninterface SqliteDatasourceOptions {\n  provider: SqliteProviderType\n  entities: Array<SqliteDatasourceEntity | string>\n  query: string\n  queryParameters?: SqliteParamExpressions\n  isDocument?: boolean\n  rewriteQuery?: boolean\n  jsonProperties?: string[] | null\n  conversions?: ConversionDefinition[]\n}\n\n/**\n * SQLite datasource definition.\n */\nexport type SqliteDatasource = DatasourceBase & {\n  readonly type: typeof DATASOURCE_TYPE.SQLITE\n  readonly options: SqliteDatasourceOptions\n  parameters?: Record<\n    ParameterName,\n    {\n      readonly type: string\n      readonly default?: ParameterValue\n      readonly required?: boolean\n    }\n  >\n}\n\n/**\n * ---\n * SqliteDatasourceBuilder Parameter Convention\n *\n * - .parameter(name, type, required?, defaultValue?)\n *   - Defines a *formal* parameter (name, type, required, default)\n *   - Like a function signature or API contract\n *   - Example:\n *     builder.parameter('userId', 'string', 'required')\n *     builder.parameter('limit', 'number', 'optional', 10)\n *\n * - .queryParameter(name, value)\n *   - Sets the *runtime value* for a parameter (constant or JSONata expression)\n *   - Like passing an argument to a function call\n *   - Example:\n *     builder.queryParameter('userId', '=@ctx.user.id')\n *     builder.queryParameter('limit', 25)\n *\n * - .param(name)\n *   - Fluent helper for setting query parameter values\n *   - Example:\n *     builder.param('userId').value(123)\n *\n * | Method              | Purpose                        | Example                                      |\n * |---------------------|--------------------------------|----------------------------------------------|\n * | .parameter()        | Define parameter (name/type)   | .parameter('userId', 'string', 'required')   |\n * | .queryParameter()   | Set value for parameter        | .queryParameter('userId', 123)               |\n * | .param()            | Fluent value setter (helper)   | .param('userId').value(123)                  |\n *\n * ---\n */\n\n/**\n * Query local SQLite database.\n *\n * Primary datasource for screens. Data stored locally as JSON.\n * Use json_extract() for field access.\n * Providers: dynamic (cloud sync) or local (device-only).\n * Parameters: $paramName in queries.\n * Sync data using sync-entities actions triggered on onLoad/onFocus/onRefresh events.\n *\n * @alias datasource.sqlite\n */\nexport interface SqliteDatasourceInput {\n  readonly datasourceId: string | DatasourceId\n  readonly provider: 'dynamic' | 'local'\n  readonly instanceId?: InstanceId\n}\n\nexport class SqliteDatasourceBuilder extends DatasourceBaseBuilder<SqliteDatasource> {\n  private readonly _requiredTables: string[] = []\n  private _explicitQuery = false\n  private _lastFromClause: string | undefined\n\n  /**\n   * Create SQLite datasource builder.\n   *\n   * @param options - Configuration options\n   * @param options.datasourceId - Unique identifier. Format: Mixedcase 2-50, prefer kebab-case, starts alpha, contains alphanum and `-`, ends alphanum\n   * @param options.provider - 'dynamic' (cloud-sync) or 'local' (device-only)\n   * @param options.instanceId - Optional instance ID (defaults to datasourceId)\n   */\n  constructor(options: SqliteDatasourceInput) {\n    const { datasourceId, provider, instanceId } = options\n    super(DATASOURCE_TYPE.SQLITE, {\n      datasourceId: toDatasourceId(datasourceId),\n      instanceId,\n    })\n\n    this._config.provider = provider === 'local' ? DATA_PROVIDER.LOCAL : DATA_PROVIDER.DYNAMIC\n    this._config.query = ''\n    this._config.entities = []\n  }\n\n  /**\n   * Validate and normalize parameter names.\n   */\n  private validateParameterName(name: string | ParameterName): string | ParameterName {\n    if (typeof name === 'string') {\n      // Remove @ prefix if present (common mistake)\n      if (name.startsWith('@')) {\n        name = name.slice(1)\n      }\n      // First try to validate as-is (ParameterNameSchema allows both $ and alpha start)\n      const result = ParameterNameSchema.safeParse(name)\n      if (result.success) {\n        return result.data\n      } else {\n        // If validation fails, use toParameterDollar which will give proper error message\n        return toParameterName(name)\n      }\n    }\n    return name\n  }\n\n  private applyDefaultQuery(fromClause: string): void {\n    if (this._explicitQuery) return\n    this._lastFromClause = fromClause\n    if (this._config.isDocument) {\n      this._config.query = `SELECT tbl.id, tbl.data\n                                     FROM ${fromClause} AS tbl`\n    } else {\n      this._config.query = `SELECT tbl.id, json_extract(tbl.data, '$.name') AS name\n                                     FROM ${fromClause} AS tbl`\n    }\n  }\n\n  /**\n   * Table names that need registration on the default database.\n   * Collected during entity() calls for dynamic-provider datasources.\n   *\n   * Note: Tables are only auto-registered when this datasource is built\n   * through ApplicationBuilder. Standalone usage requires manual table\n   * registration on the DatabaseBuilder.\n   */\n  getRequiredTables(): readonly string[] {\n    return this._requiredTables\n  }\n\n  private registerDynamicTable(entityName: string): void {\n    if (this._config.provider !== DATA_PROVIDER.DYNAMIC) return\n    this._requiredTables.push(toDatabaseTableName(entityName))\n  }\n\n  private resolveFunctionId(fn: FunctionId | FunctionCore): FunctionId {\n    if (isFunctionCore(fn)) return fn.functionId\n    if (isFunctionId(fn)) return fn\n    return toFunctionId(fn)\n  }\n\n  /**\n   * Set SQL query. Use json_extract() for JSON data.\n   * Style: UPPER keywords, [table] AS alias, $params.\n   * Include id first. Add tables via entity().\n   * Use MCP to access SQLite cheatsheet.\n   *\n   * @param sql - SQL query with json_extract() and $parameters\n   * @returns Builder for chaining\n   */\n  query(sql: string): this {\n    if (!sql || sql.trim() === '') {\n      throw new Error('Query cannot be empty or whitespace')\n    }\n    this._config.query = sql\n    this._explicitQuery = true\n    return this\n  }\n\n  /**\n   * Add entity (table) to sync/query.\n   * - String form: `entity('default/users')` → `'default/users'`\n   * - Object form: `entity({ entity: 'users' })` → `{ entity: 'users' }`\n   * - Function form: `entity({ entity: 'users', fn, params? })` → `{ entity: 'users', function: '...', ... }`\n   *\n   * @param input - Entity name or descriptor\n   * @returns Builder for chaining\n   */\n  entity(\n    input:\n      | string\n      | TableName\n      | {\n          entity: string | TableName\n          fn?: FunctionId | FunctionCore\n          params?: SqliteParamExpressions\n        },\n  ): this {\n    const entities = this._config.entities as Array<SqliteDatasourceEntity | string>\n\n    if (typeof input === 'string') {\n      const resolved = toEntityName(input, this._config.provider === DATA_PROVIDER.DYNAMIC)\n      this.registerDynamicTable(resolved)\n      entities.push(resolved)\n      this.applyDefaultQuery(`[${resolved}]`)\n    } else {\n      const resolved = toEntityName(input.entity, this._config.provider === DATA_PROVIDER.DYNAMIC)\n      this.registerDynamicTable(resolved)\n      if (input.fn) {\n        entities.push({\n          entity: resolved,\n          function: this.resolveFunctionId(input.fn),\n          functionParameters: input.params,\n        })\n      } else {\n        entities.push({ entity: resolved })\n      }\n      this.applyDefaultQuery(`[${resolved}]`)\n    }\n    return this\n  }\n\n  /**\n   * Add entity from an external package.\n   *\n   * @param name - Entity/table name\n   * @param packageName - Package name\n   * @returns Builder for chaining\n   * @example entityPackaged('Customers', 'erp')\n   */\n  entityPackaged(name: string | TableName, packageName: string): this {\n    const entities = this._config.entities as Array<SqliteDatasourceEntity | string>\n    entities.push({ entity: name, package: packageName })\n    this.applyDefaultQuery(`[${packageName}].[${name}]`)\n    return this\n  }\n\n  /**\n   * Define parameter and set value in one call.\n   * Combines parameter() and queryParameter().\n   *\n   * @param name - Parameter name (no $ prefix)\n   * @param type - Type (string, number, boolean)\n   * @param value - Runtime value or expression\n   * @param options - Required/default settings\n   * @returns Builder for chaining\n   */\n  param(\n    name: string | ParameterName,\n    type: string,\n    value: Primitive | Expression,\n    options?: {\n      required?: boolean\n      defaultValue?: Primitive | Expression\n    },\n  ): this {\n    this.parameter(name, type, {\n      required: options?.required,\n      defaultValue: options?.defaultValue,\n    })\n    this.queryParameter(name, value)\n\n    return this\n  }\n\n  /**\n   * Set runtime value for SQL parameter. Reference as $name in query.\n   * Supports static values and expressions.\n   *\n   * @param name - Parameter name (without $ prefix)\n   * @param value - Value or expression (=@ctx.*, =@ctx.jig.inputs.*)\n   * @returns This builder for chaining\n   */\n  queryParameter(\n    name: string | ParameterName,\n    value: string | number | boolean | null | PrimitiveOrExpression,\n  ): this {\n    const validatedName = this.validateParameterName(name)\n\n    if (!this._config.queryParameters) {\n      this._config.queryParameters = {}\n    }\n    ;(this._config.queryParameters as SqliteParamExpressions)[validatedName] = value\n    return this\n  }\n\n  /**\n   * Define formal parameter (like function signature).\n   * Use queryParameter() to set runtime values.\n   *\n   * @param name - Parameter name\n   * @param type - Type (string, number, boolean)\n   * @param options - Required/default settings\n   * @returns This builder for chaining\n   */\n  parameter(\n    name: string | ParameterName,\n    type: string,\n    options?: { required?: boolean; defaultValue?: ParameterValue },\n  ): this {\n    const validatedName = this.validateParameterName(name)\n\n    if (!this._config.parameters) {\n      this._config.parameters = {}\n    }\n\n    ;(this._config.parameters as NonNullable<SqliteDatasource['parameters']>)[validatedName] = {\n      type,\n      required: options?.required,\n      default: options?.defaultValue,\n    }\n\n    return this\n  }\n\n  /**\n   * Enable or disable query rewriting for shorthand syntax.\n   * When true, $.propertyName is rewritten to json_extract(data, '$.propertyName').\n   * Defaults to true.\n   *\n   * @param value - true to enable rewriting\n   * @returns This builder for chaining\n   */\n  rewriteQuery(value = true): this {\n    this._config.rewriteQuery = value\n    return this\n  }\n\n  /**\n   * Return single document instead of array. Query should return full data column.\n   * Use for detail views, single record lookups.\n   *\n   * @param value - true for document mode (default: true)\n   * @returns This builder for chaining\n   */\n  isDocument(value = true): this {\n    this._config.isDocument = value\n    if (this._lastFromClause) {\n      this.applyDefaultQuery(this._lastFromClause)\n    }\n    return this\n  }\n\n  /**\n   * Parse columns as JSON in query results.\n   * Use when storing JSON strings that need parsing.\n   *\n   * @param columns - Column names to parse\n   * @returns This builder for chaining\n   */\n  jsonProperties(...columns: string[]): this {\n    if (!this._config.jsonProperties) {\n      this._config.jsonProperties = []\n    }\n    ;(this._config.jsonProperties as string[]).push(...columns)\n    return this\n  }\n\n  /**\n   * Helper: Build SELECT query with json_extract columns.\n   * Automatically add entity and format query.\n   *\n   * @param columns - Columns to extract from data JSON\n   * @param from - Table name\n   * @param where - WHERE clause (can use $params)\n   * @param options - Table alias option\n   * @returns This builder for chaining\n   */\n  select(\n    columns: string | string[],\n    from: string | TableName | EntityName,\n    where?: string,\n    options?: { tableAlias?: string },\n  ): this {\n    this.isDocument(false)\n\n    from = toEntityName(from, this._config.provider === DATA_PROVIDER.DYNAMIC)\n    this.entity(from)\n\n    const tableAlias = options?.tableAlias || 'tbl'\n    const cols = Array.isArray(columns) ? columns : columns.split(',').map((c) => c.trim())\n    // Always ensure id is first, and not duplicated in json_extract\n    const selectCols = [`${tableAlias}.id`]\n    for (const col of cols) {\n      if (col !== 'id') {\n        selectCols.push(`json_extract(${tableAlias}.data, '$.${col}') AS ${col}`)\n      }\n    }\n    let query = `SELECT ${selectCols.join(', ')}\n                 FROM [${from}] AS ${tableAlias}`\n    if (where) query += ` WHERE ${where}`\n    this.query(query)\n    return this\n  }\n\n  /**\n   * Helper: Build document query (returns full data object).\n   * Set isDocument(true) and create appropriate query.\n   *\n   * @param from - Table name\n   * @param options - WHERE clause and alias options\n   * @returns This builder for chaining\n   */\n  selectDocument(\n    from: string | TableName | EntityName,\n    options?: { where?: string; tableAlias?: string },\n  ): this {\n    this.isDocument(true)\n\n    from = toEntityName(from, this._config.provider === DATA_PROVIDER.DYNAMIC)\n    this.entity(from)\n\n    const tableAlias = options?.tableAlias || 'tbl'\n    let query = `SELECT ${tableAlias}.id, ${tableAlias}.data\n                 FROM [${from}] AS ${tableAlias}`\n    if (options?.where) query += ` WHERE ${options.where}`\n    this.query(query)\n\n    return this\n  }\n\n  /**\n   * Helper: Add json_extract column to existing query.\n   * Modify current SELECT clause.\n   *\n   * @param column - Column name to extract\n   * @param options - Path, alias, and table options\n   * @returns This builder for chaining\n   */\n  jsonExtract(\n    column: string,\n    options?: { path?: string; alias?: string; tableAlias?: string },\n  ): this {\n    const tableAlias: string = options?.tableAlias || 'tbl'\n    const columnAlias: string = options?.alias || column\n\n    // We don't need to extract the id column, it is already directly in query\n    if (column === 'id') return this\n\n    let path: string = options?.path || column\n    if (!path.startsWith('$')) path = `$.${path}`\n\n    const currentQuery = this._config.query as string\n    if (currentQuery.includes('SELECT')) {\n      // Replace or append to select clause\n      const newColumn = `json_extract(${tableAlias}.data, '${path}') AS ${columnAlias}`\n      const modifiedQuery = currentQuery.replace(/SELECT\\s+/, `SELECT ${newColumn}, `)\n      this.query(modifiedQuery)\n    }\n    return this\n  }\n\n  /**\n   * Add multiple entities at once.\n   * Shorthand for multiple entity() calls.\n   *\n   * @param names - Entity/table names\n   * @returns This builder for chaining\n   */\n  entities(...names: Array<string | TableName | EntityName>): this {\n    names.forEach((name) => this.entity(name))\n    return this\n  }\n\n  /**\n   * Convert data between formats (images, files).\n   * Common: BASE64 → LOCAL_URI for displaying images.\n   *\n   * @param property - Property path to convert\n   * @param from - Source format\n   * @param to - Target format\n   * @param options - Optional localFilename for local-uri target, convertHeicToJpg flag\n   * @returns This builder for chaining\n   */\n  convert(\n    property: string,\n    from: 'buffer' | 'local-uri' | 'base64' | 'data-uri',\n    to: 'buffer' | 'base64' | 'data-uri',\n    options?: { convertHeicToJpg?: boolean },\n  ): this\n\n  convert(\n    property: string,\n    from: 'buffer' | 'local-uri' | 'base64' | 'data-uri',\n    to: 'local-uri',\n    options?: { localFilename?: string; convertHeicToJpg?: boolean },\n  ): this\n\n  convert(\n    property: string,\n    from: 'buffer' | 'local-uri' | 'base64' | 'data-uri',\n    to: 'buffer' | 'base64' | 'data-uri' | 'local-uri',\n    options?: { localFilename?: string; convertHeicToJpg?: boolean },\n  ): this {\n    if (!this._config.conversions) {\n      this._config.conversions = []\n    }\n\n    let conversion: ConversionDefinition\n    if (to === 'local-uri') {\n      conversion = options?.localFilename\n        ? { property, from, to, localFilename: options.localFilename }\n        : { property, from, to }\n    } else {\n      conversion = { property, from, to }\n    }\n    if (options?.convertHeicToJpg !== undefined) {\n      conversion.convertHeicToJpg = options.convertHeicToJpg\n    }\n\n    ;(this._config.conversions as ConversionDefinition[]).push(conversion)\n    return this\n  }\n\n  /**\n   * Build and return SQLite datasource definition.\n   * @returns Complete SQLite datasource configuration\n   */\n  override build(): SqliteDatasource {\n    const query = this._config.query as string\n    const entities = this._config.entities as Array<SqliteDatasourceEntity | string>\n    const provider = this._config.provider as SqliteProviderType\n\n    // Validate that we have a non-empty query\n    if (!query || query.trim() === '') {\n      throw new Error('Query cannot be empty or whitespace')\n    }\n\n    // Extract table names from entities (including package prefix for external packages)\n    const tableNames = entities.map((entity) => {\n      if (typeof entity === 'string') return entity\n      // For package entities, use the full [package].[table] format that appears in queries\n      if (entity.package) {\n        return `[${entity.package}].[${entity.entity}]`\n      }\n      return entity.entity\n    })\n\n    // Create in-memory database with all tables for validation\n    const { db, tables } = createValidationDatabase(tableNames)\n\n    // Working copy for validation\n    let validationQuery = query\n\n    try {\n      // Apply all table name transformations to query\n      tables.forEach(({ safeName, normalizedName }) => {\n        if (safeName !== normalizedName) {\n          validationQuery = replaceTableName(validationQuery, normalizedName, safeName)\n        }\n      })\n\n      // Replace named parameters with positional placeholders for validation\n      validationQuery = replaceParameters(validationQuery)\n\n      // Validate query syntax and ensure it's a SELECT\n      validateSelectQuery(db, validationQuery)\n\n      // Assemble the output\n      const options: SqliteDatasourceOptions = {\n        provider,\n        entities,\n        query,\n      }\n\n      if (this._config.queryParameters) {\n        options.queryParameters = this._config.queryParameters as SqliteParamExpressions\n      }\n      if (this._config.isDocument !== undefined) {\n        options.isDocument = this._config.isDocument as boolean\n      }\n      if (this._config.rewriteQuery !== undefined) {\n        options.rewriteQuery = this._config.rewriteQuery as boolean\n      }\n      if (this._config.jsonProperties) {\n        options.jsonProperties = this._config.jsonProperties as string[]\n      }\n      if (this._config.conversions) {\n        options.conversions = this._config.conversions as ConversionDefinition[]\n      }\n\n      const result: SqliteDatasource = {\n        type: DATASOURCE_TYPE.SQLITE,\n        datasourceId: this.datasourceId,\n        instanceId: this.instanceId,\n        options,\n      }\n\n      if (this._config.parameters) {\n        result.parameters = this._config.parameters as NonNullable<SqliteDatasource['parameters']>\n      }\n\n      return result\n    } catch (error) {\n      // Provide helpful error message with original query (not transformed validation query)\n      const errorMsg = error instanceof Error ? error.message : String(error)\n      throw new Error(`Invalid SQL query: ${errorMsg}\\n\\nQuery: ${query}`)\n    } finally {\n      // Always close the database\n      db.close()\n    }\n  }\n}\n"]}