@jigx/core-sdk 1.0.0

package/dist/datasource/datasource.sqlite.js

@@ -0,0 +1,286 @@
+import { DATA_PROVIDER, DATASOURCE_TYPE, isFunctionId, ParameterNameSchema, toDatabaseTableName, toDatasourceId, toEntityName, toFunctionId, toParameterName, } from '../abstract/index.js';
+import { isFunctionCore } from '../function/index.js';
+import { DatasourceBaseBuilder } from './datasource.abstract.js';
+import { createValidationDatabase, replaceParameters, replaceTableName, validateSelectQuery, } from './sqlite-validator.js';
+export class SqliteDatasourceBuilder extends DatasourceBaseBuilder {
+    _requiredTables = [];
+    _explicitQuery = false;
+    _lastFromClause;
+    constructor(options) {
+        const { datasourceId, provider, instanceId } = options;
+        super(DATASOURCE_TYPE.SQLITE, {
+            datasourceId: toDatasourceId(datasourceId),
+            instanceId,
+        });
+        this._config.provider = provider === 'local' ? DATA_PROVIDER.LOCAL : DATA_PROVIDER.DYNAMIC;
+        this._config.query = '';
+        this._config.entities = [];
+    }
+    validateParameterName(name) {
+        if (typeof name === 'string') {
+            if (name.startsWith('@')) {
+                name = name.slice(1);
+            }
+            const result = ParameterNameSchema.safeParse(name);
+            if (result.success) {
+                return result.data;
+            }
+            else {
+                return toParameterName(name);
+            }
+        }
+        return name;
+    }
+    applyDefaultQuery(fromClause) {
+        if (this._explicitQuery)
+            return;
+        this._lastFromClause = fromClause;
+        if (this._config.isDocument) {
+            this._config.query = `SELECT tbl.id, tbl.data
+                                     FROM ${fromClause} AS tbl`;
+        }
+        else {
+            this._config.query = `SELECT tbl.id, json_extract(tbl.data, '$.name') AS name
+                                     FROM ${fromClause} AS tbl`;
+        }
+    }
+    getRequiredTables() {
+        return this._requiredTables;
+    }
+    registerDynamicTable(entityName) {
+        if (this._config.provider !== DATA_PROVIDER.DYNAMIC)
+            return;
+        this._requiredTables.push(toDatabaseTableName(entityName));
+    }
+    resolveFunctionId(fn) {
+        if (isFunctionCore(fn))
+            return fn.functionId;
+        if (isFunctionId(fn))
+            return fn;
+        return toFunctionId(fn);
+    }
+    query(sql) {
+        if (!sql || sql.trim() === '') {
+            throw new Error('Query cannot be empty or whitespace');
+        }
+        this._config.query = sql;
+        this._explicitQuery = true;
+        return this;
+    }
+    entity(input) {
+        const entities = this._config.entities;
+        if (typeof input === 'string') {
+            const resolved = toEntityName(input, this._config.provider === DATA_PROVIDER.DYNAMIC);
+            this.registerDynamicTable(resolved);
+            entities.push(resolved);
+            this.applyDefaultQuery(`[${resolved}]`);
+        }
+        else {
+            const resolved = toEntityName(input.entity, this._config.provider === DATA_PROVIDER.DYNAMIC);
+            this.registerDynamicTable(resolved);
+            if (input.fn) {
+                entities.push({
+                    entity: resolved,
+                    function: this.resolveFunctionId(input.fn),
+                    functionParameters: input.params,
+                });
+            }
+            else {
+                entities.push({ entity: resolved });
+            }
+            this.applyDefaultQuery(`[${resolved}]`);
+        }
+        return this;
+    }
+    entityPackaged(name, packageName) {
+        const entities = this._config.entities;
+        entities.push({ entity: name, package: packageName });
+        this.applyDefaultQuery(`[${packageName}].[${name}]`);
+        return this;
+    }
+    param(name, type, value, options) {
+        this.parameter(name, type, {
+            required: options?.required,
+            defaultValue: options?.defaultValue,
+        });
+        this.queryParameter(name, value);
+        return this;
+    }
+    queryParameter(name, value) {
+        const validatedName = this.validateParameterName(name);
+        if (!this._config.queryParameters) {
+            this._config.queryParameters = {};
+        }
+        ;
+        this._config.queryParameters[validatedName] = value;
+        return this;
+    }
+    parameter(name, type, options) {
+        const validatedName = this.validateParameterName(name);
+        if (!this._config.parameters) {
+            this._config.parameters = {};
+        }
+        ;
+        this._config.parameters[validatedName] = {
+            type,
+            required: options?.required,
+            default: options?.defaultValue,
+        };
+        return this;
+    }
+    rewriteQuery(value = true) {
+        this._config.rewriteQuery = value;
+        return this;
+    }
+    isDocument(value = true) {
+        this._config.isDocument = value;
+        if (this._lastFromClause) {
+            this.applyDefaultQuery(this._lastFromClause);
+        }
+        return this;
+    }
+    jsonProperties(...columns) {
+        if (!this._config.jsonProperties) {
+            this._config.jsonProperties = [];
+        }
+        ;
+        this._config.jsonProperties.push(...columns);
+        return this;
+    }
+    select(columns, from, where, options) {
+        this.isDocument(false);
+        from = toEntityName(from, this._config.provider === DATA_PROVIDER.DYNAMIC);
+        this.entity(from);
+        const tableAlias = options?.tableAlias || 'tbl';
+        const cols = Array.isArray(columns) ? columns : columns.split(',').map((c) => c.trim());
+        const selectCols = [`${tableAlias}.id`];
+        for (const col of cols) {
+            if (col !== 'id') {
+                selectCols.push(`json_extract(${tableAlias}.data, '$.${col}') AS ${col}`);
+            }
+        }
+        let query = `SELECT ${selectCols.join(', ')}
+                 FROM [${from}] AS ${tableAlias}`;
+        if (where)
+            query += ` WHERE ${where}`;
+        this.query(query);
+        return this;
+    }
+    selectDocument(from, options) {
+        this.isDocument(true);
+        from = toEntityName(from, this._config.provider === DATA_PROVIDER.DYNAMIC);
+        this.entity(from);
+        const tableAlias = options?.tableAlias || 'tbl';
+        let query = `SELECT ${tableAlias}.id, ${tableAlias}.data
+                 FROM [${from}] AS ${tableAlias}`;
+        if (options?.where)
+            query += ` WHERE ${options.where}`;
+        this.query(query);
+        return this;
+    }
+    jsonExtract(column, options) {
+        const tableAlias = options?.tableAlias || 'tbl';
+        const columnAlias = options?.alias || column;
+        if (column === 'id')
+            return this;
+        let path = options?.path || column;
+        if (!path.startsWith('$'))
+            path = `$.${path}`;
+        const currentQuery = this._config.query;
+        if (currentQuery.includes('SELECT')) {
+            const newColumn = `json_extract(${tableAlias}.data, '${path}') AS ${columnAlias}`;
+            const modifiedQuery = currentQuery.replace(/SELECT\s+/, `SELECT ${newColumn}, `);
+            this.query(modifiedQuery);
+        }
+        return this;
+    }
+    entities(...names) {
+        names.forEach((name) => this.entity(name));
+        return this;
+    }
+    convert(property, from, to, options) {
+        if (!this._config.conversions) {
+            this._config.conversions = [];
+        }
+        let conversion;
+        if (to === 'local-uri') {
+            conversion = options?.localFilename
+                ? { property, from, to, localFilename: options.localFilename }
+                : { property, from, to };
+        }
+        else {
+            conversion = { property, from, to };
+        }
+        if (options?.convertHeicToJpg !== undefined) {
+            conversion.convertHeicToJpg = options.convertHeicToJpg;
+        }
+        ;
+        this._config.conversions.push(conversion);
+        return this;
+    }
+    build() {
+        const query = this._config.query;
+        const entities = this._config.entities;
+        const provider = this._config.provider;
+        if (!query || query.trim() === '') {
+            throw new Error('Query cannot be empty or whitespace');
+        }
+        const tableNames = entities.map((entity) => {
+            if (typeof entity === 'string')
+                return entity;
+            if (entity.package) {
+                return `[${entity.package}].[${entity.entity}]`;
+            }
+            return entity.entity;
+        });
+        const { db, tables } = createValidationDatabase(tableNames);
+        let validationQuery = query;
+        try {
+            tables.forEach(({ safeName, normalizedName }) => {
+                if (safeName !== normalizedName) {
+                    validationQuery = replaceTableName(validationQuery, normalizedName, safeName);
+                }
+            });
+            validationQuery = replaceParameters(validationQuery);
+            validateSelectQuery(db, validationQuery);
+            const options = {
+                provider,
+                entities,
+                query,
+            };
+            if (this._config.queryParameters) {
+                options.queryParameters = this._config.queryParameters;
+            }
+            if (this._config.isDocument !== undefined) {
+                options.isDocument = this._config.isDocument;
+            }
+            if (this._config.rewriteQuery !== undefined) {
+                options.rewriteQuery = this._config.rewriteQuery;
+            }
+            if (this._config.jsonProperties) {
+                options.jsonProperties = this._config.jsonProperties;
+            }
+            if (this._config.conversions) {
+                options.conversions = this._config.conversions;
+            }
+            const result = {
+                type: DATASOURCE_TYPE.SQLITE,
+                datasourceId: this.datasourceId,
+                instanceId: this.instanceId,
+                options,
+            };
+            if (this._config.parameters) {
+                result.parameters = this._config.parameters;
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid SQL query: ${errorMsg}\n\nQuery: ${query}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datasource.sqlite.js","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.static.d.ts

@@ -0,0 +1,21 @@
+import { DATASOURCE_TYPE, type DatasourceId, type Primitive } from '../abstract/index.js';
+import { DatasourceBaseBuilder } from './datasource.abstract.js';
+export type StaticDatasource = {
+    type: typeof DATASOURCE_TYPE.STATIC;
+    datasourceId: DatasourceId;
+    instanceId?: string;
+    options: {
+        data: unknown[];
+    };
+};
+export type InlineData = Array<Primitive | Record<string, unknown>>;
+export interface StaticDatasourceInput {
+    readonly datasourceId: string | DatasourceId;
+    readonly data?: InlineData;
+}
+export declare class StaticDatasourceBuilder extends DatasourceBaseBuilder<StaticDatasource> {
+    constructor(options: StaticDatasourceInput);
+    csv(csvString: string, delimiter?: string): this;
+    json(jsonString: string): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.static.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.static.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AAKhE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,eAAe,CAAC,MAAM,CAAA;IACnC,YAAY,EAAE,YAAY,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE;QAAE,IAAI,EAAE,OAAO,EAAE,CAAA;KAAE,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAanE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,CAAA;IAC5C,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAA;CAC3B;AAED,qBAAa,uBAAwB,SAAQ,qBAAqB,CAAC,gBAAgB,CAAC;IAQlF,YAAY,OAAO,EAAE,qBAAqB,EAOzC;IAUD,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,IAAI,CAG5C;IAWD,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAW7B;CACF","sourcesContent":["import { DATASOURCE_TYPE, type DatasourceId, type Primitive } from '../abstract/index.js'\nimport { DatasourceBaseBuilder } from './datasource.abstract.js'\n\n/**\n * Static datasource definition.\n */\nexport type StaticDatasource = {\n  type: typeof DATASOURCE_TYPE.STATIC\n  datasourceId: DatasourceId\n  instanceId?: string\n  options: { data: unknown[] }\n}\n\nexport type InlineData = Array<Primitive | Record<string, unknown>>\n\n/**\n * Define fixed data directly in code.\n * Use for dropdown options, config, lookups.\n * Data embedded at build time, no sync needed.\n * Always available offline with zero latency.\n * Accept arrays of objects or primitives.\n * Global datasources prevent duplication.\n * Update requires republishing application.\n * Not for frequently changing data.\n * @alias datasource.static\n */\nexport interface StaticDatasourceInput {\n  readonly datasourceId: string | DatasourceId\n  readonly data?: InlineData\n}\n\nexport class StaticDatasourceBuilder extends DatasourceBaseBuilder<StaticDatasource> {\n  /**\n   * Creates a new static datasource builder with optional embedded data.\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.data - Optional array of primitive values or objects to embed (defaults to empty array)\n   * @throws {Error} If data is provided but not an array\n   */\n  constructor(options: StaticDatasourceInput) {\n    const { datasourceId, data = [] } = options\n    super(DATASOURCE_TYPE.STATIC, { datasourceId })\n    if (typeof data !== 'undefined' && !Array.isArray(data)) {\n      throw new Error('Data must be an array')\n    }\n    this._config.data = data\n  }\n\n  /**\n   * Set data from delimited string.\n   * Splits on delimiter and trims whitespace from each item.\n   *\n   * @param csvString - Delimited string values\n   * @param delimiter - Optional delimiter (defaults to comma)\n   * @returns This builder for chaining\n   */\n  csv(csvString: string, delimiter = ','): this {\n    this._config.data = csvString.split(delimiter).map((item) => item.trim())\n    return this\n  }\n\n  /**\n   * Set data from JSON string.\n   * Arrays set directly, objects converted to key-value pairs.\n   *\n   * @param jsonString - JSON string to parse\n   * @returns This builder for chaining\n   * @throws {SyntaxError} If JSON is invalid\n   * @throws {Error} If JSON is not an array or object\n   */\n  json(jsonString: string): this {\n    const parsed = JSON.parse(jsonString)\n\n    if (Array.isArray(parsed)) {\n      this._config.data = parsed\n    } else if (parsed && typeof parsed === 'object') {\n      this._config.data = Object.entries(parsed).map(([key, value]) => ({ key, value }))\n    } else {\n      throw new Error('JSON must be an array or object')\n    }\n    return this\n  }\n}\n"]}

package/dist/datasource/datasource.static.js

@@ -0,0 +1,30 @@
+import { DATASOURCE_TYPE } from '../abstract/index.js';
+import { DatasourceBaseBuilder } from './datasource.abstract.js';
+export class StaticDatasourceBuilder extends DatasourceBaseBuilder {
+    constructor(options) {
+        const { datasourceId, data = [] } = options;
+        super(DATASOURCE_TYPE.STATIC, { datasourceId });
+        if (typeof data !== 'undefined' && !Array.isArray(data)) {
+            throw new Error('Data must be an array');
+        }
+        this._config.data = data;
+    }
+    csv(csvString, delimiter = ',') {
+        this._config.data = csvString.split(delimiter).map((item) => item.trim());
+        return this;
+    }
+    json(jsonString) {
+        const parsed = JSON.parse(jsonString);
+        if (Array.isArray(parsed)) {
+            this._config.data = parsed;
+        }
+        else if (parsed && typeof parsed === 'object') {
+            this._config.data = Object.entries(parsed).map(([key, value]) => ({ key, value }));
+        }
+        else {
+            throw new Error('JSON must be an array or object');
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource/datasource.system.d.ts

@@ -0,0 +1,18 @@
+import { DATASOURCE_TYPE, type DatasourceId, type InstanceId } from '../abstract/index.js';
+import { DatasourceBaseBuilder } from './datasource.abstract.js';
+export type SystemDatasource = {
+    type: typeof DATASOURCE_TYPE.SYSTEM;
+    datasourceId: DatasourceId;
+    instanceId?: string;
+    options: {
+        source: 'flags';
+    };
+};
+export interface SystemDatasourceInput {
+    readonly datasourceId: string | DatasourceId;
+    readonly instanceId?: InstanceId;
+}
+export declare class SystemDatasourceBuilder extends DatasourceBaseBuilder<SystemDatasource> {
+    constructor(options: SystemDatasourceInput);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.system.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.system.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAC1F,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AAKhE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,OAAO,eAAe,CAAC,MAAM,CAAA;IACnC,YAAY,EAAE,YAAY,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAA;CAC7B,CAAA;AAaD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,CAAA;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;CACjC;AAED,qBAAa,uBAAwB,SAAQ,qBAAqB,CAAC,gBAAgB,CAAC;IAOlF,YAAY,OAAO,EAAE,qBAAqB,EAIzC;CACF","sourcesContent":["import { DATASOURCE_TYPE, type DatasourceId, type InstanceId } from '../abstract/index.js'\nimport { DatasourceBaseBuilder } from './datasource.abstract.js'\n\n/**\n * System datasource definition.\n */\nexport type SystemDatasource = {\n  type: typeof DATASOURCE_TYPE.SYSTEM\n  datasourceId: DatasourceId\n  instanceId?: string\n  options: { source: 'flags' }\n}\n\n/**\n * Access system-provided data (flags only).\n * Returns array of countries with flag emojis.\n * Each item has: code, name, flag properties.\n * Use for country dropdowns or flag displays.\n * No configuration needed, just source: flags.\n * Always up-to-date with all countries.\n * Flag emojis work as icons in components.\n * Zero maintenance required.\n * @alias datasource.system\n */\nexport interface SystemDatasourceInput {\n  readonly datasourceId: string | DatasourceId\n  readonly instanceId?: InstanceId\n}\n\nexport class SystemDatasourceBuilder extends DatasourceBaseBuilder<SystemDatasource> {\n  /**\n   * Creates a new system datasource builder.\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.instanceId - Optional instance identifier (defaults to datasourceId)\n   */\n  constructor(options: SystemDatasourceInput) {\n    const { datasourceId, instanceId } = options\n    super(DATASOURCE_TYPE.SYSTEM, { datasourceId, instanceId })\n    this._config.source = 'flags'\n  }\n}\n"]}

package/dist/datasource/datasource.system.js

@@ -0,0 +1,10 @@
+import { DATASOURCE_TYPE } from '../abstract/index.js';
+import { DatasourceBaseBuilder } from './datasource.abstract.js';
+export class SystemDatasourceBuilder extends DatasourceBaseBuilder {
+    constructor(options) {
+        const { datasourceId, instanceId } = options;
+        super(DATASOURCE_TYPE.SYSTEM, { datasourceId, instanceId });
+        this._config.source = 'flags';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource/entity.descriptor.d.ts

@@ -0,0 +1,9 @@
+import { type ActionId } from '../abstract/index.js';
+export interface EntityDescriptor {
+    readonly packageName?: string;
+    readonly entityName: string;
+    readonly description?: string;
+    readonly syncAction?: ActionId;
+    readonly syncExpand?: string;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LmRlc2NyaXB0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYXRhc291cmNlL2VudGl0eS5kZXNjcmlwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLFFBQVEsRUFBRSxNQUFNLHNCQUFzQixDQUFBO0FBRXBELE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0IsUUFBUSxDQUFDLFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtJQUM3QixRQUFRLENBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQTtJQUMzQixRQUFRLENBQUMsV0FBVyxDQUFDLEVBQUUsTUFBTSxDQUFBO0lBQzdCLFFBQVEsQ0FBQyxVQUFVLENBQUMsRUFBRSxRQUFRLENBQUE7SUFFOUIsUUFBUSxDQUFDLFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtDQUM3QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgQWN0aW9uSWQgfSBmcm9tICcuLi9hYnN0cmFjdC9pbmRleC5qcydcblxuZXhwb3J0IGludGVyZmFjZSBFbnRpdHlEZXNjcmlwdG9yIHtcbiAgcmVhZG9ubHkgcGFja2FnZU5hbWU/OiBzdHJpbmdcbiAgcmVhZG9ubHkgZW50aXR5TmFtZTogc3RyaW5nXG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uPzogc3RyaW5nXG4gIHJlYWRvbmx5IHN5bmNBY3Rpb24/OiBBY3Rpb25JZFxuICAvKiogT0RhdGEgJGV4cGFuZCB2YWx1ZSB0byB1c2Ugd2hlbiBzeW5jaW5nIHRoaXMgZW50aXR5ICovXG4gIHJlYWRvbmx5IHN5bmNFeHBhbmQ/OiBzdHJpbmdcbn1cbiJdfQ==

package/dist/datasource/entity.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.descriptor.d.ts","sourceRoot":"","sources":["../../src/datasource/entity.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAA;IAE9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B","sourcesContent":["import { type ActionId } from '../abstract/index.js'\n\nexport interface EntityDescriptor {\n  readonly packageName?: string\n  readonly entityName: string\n  readonly description?: string\n  readonly syncAction?: ActionId\n  /** OData $expand value to use when syncing this entity */\n  readonly syncExpand?: string\n}\n"]}

package/dist/datasource/entity.descriptor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LmRlc2NyaXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YXNvdXJjZS9lbnRpdHkuZGVzY3JpcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBBY3Rpb25JZCB9IGZyb20gJy4uL2Fic3RyYWN0L2luZGV4LmpzJ1xuXG5leHBvcnQgaW50ZXJmYWNlIEVudGl0eURlc2NyaXB0b3Ige1xuICByZWFkb25seSBwYWNrYWdlTmFtZT86IHN0cmluZ1xuICByZWFkb25seSBlbnRpdHlOYW1lOiBzdHJpbmdcbiAgcmVhZG9ubHkgZGVzY3JpcHRpb24/OiBzdHJpbmdcbiAgcmVhZG9ubHkgc3luY0FjdGlvbj86IEFjdGlvbklkXG4gIC8qKiBPRGF0YSAkZXhwYW5kIHZhbHVlIHRvIHVzZSB3aGVuIHN5bmNpbmcgdGhpcyBlbnRpdHkgKi9cbiAgcmVhZG9ubHkgc3luY0V4cGFuZD86IHN0cmluZ1xufVxuIl19

package/dist/datasource/index.d.ts

@@ -0,0 +1,11 @@
+export * from './datasource.abstract.js';
+export * from './datasource.reference.js';
+export * from './datasource.sdk.js';
+export * from './datasource.sqlite.js';
+export * from './datasource.static.js';
+export * from './datasource.system.js';
+export * from './sqlite-normalizer.js';
+export * from './sqlite-validator.js';
+export type * from './datasource.descriptor.js';
+export type * from './entity.descriptor.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYXRhc291cmNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUE7QUFDeEMsY0FBYywyQkFBMkIsQ0FBQTtBQUN6QyxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLHdCQUF3QixDQUFBO0FBQ3RDLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyx1QkFBdUIsQ0FBQTtBQUVyQyxtQkFBbUIsNEJBQTRCLENBQUE7QUFDL0MsbUJBQW1CLHdCQUF3QixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRhc291cmNlLmFic3RyYWN0LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhc291cmNlLnJlZmVyZW5jZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vZGF0YXNvdXJjZS5zZGsuanMnXG5leHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2Uuc3FsaXRlLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhc291cmNlLnN0YXRpYy5qcydcbmV4cG9ydCAqIGZyb20gJy4vZGF0YXNvdXJjZS5zeXN0ZW0uanMnXG5leHBvcnQgKiBmcm9tICcuL3NxbGl0ZS1ub3JtYWxpemVyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9zcWxpdGUtdmFsaWRhdG9yLmpzJ1xuXG5leHBvcnQgdHlwZSAqIGZyb20gJy4vZGF0YXNvdXJjZS5kZXNjcmlwdG9yLmpzJ1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL2VudGl0eS5kZXNjcmlwdG9yLmpzJ1xuIl19

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datasource/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AAErC,mBAAmB,4BAA4B,CAAA;AAC/C,mBAAmB,wBAAwB,CAAA","sourcesContent":["export * from './datasource.abstract.js'\nexport * from './datasource.reference.js'\nexport * from './datasource.sdk.js'\nexport * from './datasource.sqlite.js'\nexport * from './datasource.static.js'\nexport * from './datasource.system.js'\nexport * from './sqlite-normalizer.js'\nexport * from './sqlite-validator.js'\n\nexport type * from './datasource.descriptor.js'\nexport type * from './entity.descriptor.js'\n"]}

package/dist/datasource/index.js

@@ -0,0 +1,9 @@
+export * from './datasource.abstract.js';
+export * from './datasource.reference.js';
+export * from './datasource.sdk.js';
+export * from './datasource.sqlite.js';
+export * from './datasource.static.js';
+export * from './datasource.system.js';
+export * from './sqlite-normalizer.js';
+export * from './sqlite-validator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YXNvdXJjZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFBO0FBQ3hDLGNBQWMsMkJBQTJCLENBQUE7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLHdCQUF3QixDQUFBO0FBQ3RDLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLHdCQUF3QixDQUFBO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2UuYWJzdHJhY3QuanMnXG5leHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2UucmVmZXJlbmNlLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhc291cmNlLnNkay5qcydcbmV4cG9ydCAqIGZyb20gJy4vZGF0YXNvdXJjZS5zcWxpdGUuanMnXG5leHBvcnQgKiBmcm9tICcuL2RhdGFzb3VyY2Uuc3RhdGljLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhc291cmNlLnN5c3RlbS5qcydcbmV4cG9ydCAqIGZyb20gJy4vc3FsaXRlLW5vcm1hbGl6ZXIuanMnXG5leHBvcnQgKiBmcm9tICcuL3NxbGl0ZS12YWxpZGF0b3IuanMnXG5cbmV4cG9ydCB0eXBlICogZnJvbSAnLi9kYXRhc291cmNlLmRlc2NyaXB0b3IuanMnXG5leHBvcnQgdHlwZSAqIGZyb20gJy4vZW50aXR5LmRlc2NyaXB0b3IuanMnXG4iXX0=

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

@@ -0,0 +1,3 @@
+export declare function normalizeQuery(query: string): string;
+export declare function queriesEquivalent(a: string, b: string): boolean;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sqlite-normalizer.d.ts","sourceRoot":"","sources":["../../src/datasource/sqlite-normalizer.ts"],"names":[],"mappings":"AA+PA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKpD;AAaD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAE/D","sourcesContent":["import { type AST } from 'node-sql-parser'\nimport SqliteParser from 'node-sql-parser/build/sqlite.js'\n\nconst SqlParserClass = SqliteParser.Parser\n\n// Use SQLite grammar for parsing; output with TransactSQL bracket quoting.\n// The SQLite build does not accept [bracket] quoting as input, so we pre-process\n// [foo] → `foo` (backtick), which the SQLite grammar accepts and normalizes to \"foo\".\n// sqlify with TransactSQL opts then re-emits all identifiers as [foo].\nconst SQLITE_OPT = { database: 'SQLite' }\nconst TSQL_OPT = { database: 'TransactSQL' }\nconst sqlParser = new SqlParserClass()\n\n/** Convert [bracket] identifiers to backtick so the SQLite parser accepts them. */\nfunction bracketsToBackticks(query: string): string {\n  let result = ''\n  let i = 0\n\n  let inSingleQuote = false\n  let inDoubleQuote = false\n  let inBacktick = false\n  let inLineComment = false\n  let inBlockComment = false\n\n  while (i < query.length) {\n    const char = query[i]\n    const next = i + 1 < query.length ? query[i + 1] : ''\n\n    // Handle end of line comment\n    if (inLineComment) {\n      result += char\n      if (char === '\\n') {\n        inLineComment = false\n      }\n      i += 1\n      continue\n    }\n\n    // Handle end of block comment\n    if (inBlockComment) {\n      result += char\n      if (char === '*' && next === '/') {\n        result += next\n        inBlockComment = false\n        i += 2\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle single-quoted strings, preserving content verbatim.\n    if (inSingleQuote) {\n      result += char\n      if (char === \"'\" && next === \"'\") {\n        // Escaped single quote: consume both quotes.\n        result += next\n        i += 2\n      } else if (char === \"'\") {\n        inSingleQuote = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle double-quoted identifiers/strings.\n    if (inDoubleQuote) {\n      result += char\n      if (char === '\"' && next === '\"') {\n        // Escaped double quote: consume both quotes.\n        result += next\n        i += 2\n      } else if (char === '\"') {\n        inDoubleQuote = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle backtick-quoted identifiers.\n    if (inBacktick) {\n      result += char\n      if (char === '`' && next === '`') {\n        // Escaped backtick: consume both backticks.\n        result += next\n        i += 2\n      } else if (char === '`') {\n        inBacktick = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // We are not currently inside a string or comment.\n    // Check for start of comments first.\n    if (char === '-' && next === '-') {\n      result += char + next\n      inLineComment = true\n      i += 2\n      continue\n    }\n\n    if (char === '/' && next === '*') {\n      result += char + next\n      inBlockComment = true\n      i += 2\n      continue\n    }\n\n    // Check for start of strings / quoted identifiers.\n    if (char === \"'\") {\n      result += char\n      inSingleQuote = true\n      i += 1\n      continue\n    }\n\n    if (char === '\"') {\n      result += char\n      inDoubleQuote = true\n      i += 1\n      continue\n    }\n\n    if (char === '`') {\n      result += char\n      inBacktick = true\n      i += 1\n      continue\n    }\n\n    // Perform [bracket] → `backtick` replacement only outside literals/comments.\n    // Handle ]] as escaped ] inside bracket-quoted identifiers (like '' in strings).\n    if (char === '[') {\n      let inner = ''\n      let j = i + 1\n      let closed = false\n      while (j < query.length) {\n        if (query[j] === ']') {\n          if (j + 1 < query.length && query[j + 1] === ']') {\n            // Escaped ]] → literal ]\n            inner += ']'\n            j += 2\n          } else {\n            // Closing bracket\n            closed = true\n            j += 1\n            break\n          }\n        } else {\n          inner += query[j]\n          j += 1\n        }\n      }\n      if (closed) {\n        result += '`' + inner + '`'\n        i = j\n        continue\n      }\n      // No matching ']' found — treat as a normal character.\n      result += char\n      i += 1\n      continue\n    }\n\n    // Default: copy character as-is.\n    result += char\n    i += 1\n  }\n\n  return result\n}\n\n/** Build a json_extract(data, path) AST function-call node. */\nfunction makeJsonExtractNode(path: string): object {\n  return {\n    type: 'function',\n    name: { name: [{ type: 'default', value: 'json_extract' }] },\n    args: {\n      type: 'expr_list',\n      value: [\n        { type: 'column_ref', table: null, column: 'data', collate: null },\n        { type: 'single_quote_string', value: path },\n      ],\n    },\n    over: null,\n  }\n}\n\n/**\n * Recursively walk an AST node tree, replacing bare `'$.path'` string-literal\n * nodes with json_extract function-call nodes. Existing json_extract calls are\n * left untouched so shorthand is never double-expanded.\n */\nfunction expandShorthandInAst(node: unknown): unknown {\n  if (node === null || typeof node !== 'object') return node\n\n  const obj = node as Record<string, unknown>\n\n  // Bare shorthand: single_quote_string whose value starts with '$.'\n  if (\n    obj.type === 'single_quote_string' &&\n    typeof obj.value === 'string' &&\n    obj.value.startsWith('$.')\n  ) {\n    return makeJsonExtractNode(obj.value)\n  }\n\n  // Skip args of existing json_extract calls — they are already expanded.\n  if (obj.type === 'function') {\n    const nameArr = (obj.name as Record<string, unknown>)?.name as\n      | Array<Record<string, unknown>>\n      | undefined\n    if (nameArr?.[0]?.value === 'json_extract') return node\n  }\n\n  // Recurse into all child properties.\n  const result: Record<string, unknown> = {}\n  for (const [key, val] of Object.entries(obj)) {\n    result[key] = Array.isArray(val) ? val.map(expandShorthandInAst) : expandShorthandInAst(val)\n  }\n  return result\n}\n\n/**\n * Lowercase non-literal content for case-insensitive comparison.\n * Single-quoted string literals are preserved verbatim.\n */\nfunction lowercaseIdentifiers(query: string): string {\n  const parts = query.split(/(\\'(?:[^\\']|\\'\\')*\\')/g)\n  return parts.map((part, i) => (i % 2 === 0 ? part.toLowerCase() : part)).join('')\n}\n\n/**\n * Normalize a SQL query to a canonical, reusable form.\n *\n * Applies the following transformations:\n * 1. Convert `[bracket]` identifiers to backtick for parser input\n * 2. Parse with the SQLite grammar (strips comments, validates structure)\n * 3. Expand `'$.path'` shorthand to `json_extract(data, '$.path')` via AST walk\n * 4. Re-emit with TransactSQL bracket quoting — all identifiers become `[name]`\n *    and SQL keywords are uppercased\n *\n * The result is valid SQL suitable for reuse. Use `queriesEquivalent` for\n * case-insensitive comparison.\n *\n * @param query - SQL query to normalize\n * @returns Canonical form of the query\n */\nexport function normalizeQuery(query: string): string {\n  const preprocessed: string = bracketsToBackticks(query)\n  const ast: AST | AST[] = sqlParser.astify(preprocessed, SQLITE_OPT)\n  const transformed = Array.isArray(ast) ? ast.map(expandShorthandInAst) : expandShorthandInAst(ast)\n  return sqlParser.sqlify(transformed as AST | AST[], TSQL_OPT)\n}\n\n/**\n * Compare two SQL queries for semantic equivalence.\n *\n * Ignores differences in whitespace, keyword case, identifier case, square\n * bracket quoting, and the `'$.path'` json_extract shorthand. String literal\n * values are case-sensitive (`'Active'` ≠ `'active'`).\n *\n * @param a - First SQL query\n * @param b - Second SQL query\n * @returns true if the queries are semantically equivalent\n */\nexport function queriesEquivalent(a: string, b: string): boolean {\n  return lowercaseIdentifiers(normalizeQuery(a)) === lowercaseIdentifiers(normalizeQuery(b))\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-normalizer.d.ts","sourceRoot":"","sources":["../../src/datasource/sqlite-normalizer.ts"],"names":[],"mappings":"AA+PA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKpD;AAaD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAE/D","sourcesContent":["import { type AST } from 'node-sql-parser'\nimport SqliteParser from 'node-sql-parser/build/sqlite.js'\n\nconst SqlParserClass = SqliteParser.Parser\n\n// Use SQLite grammar for parsing; output with TransactSQL bracket quoting.\n// The SQLite build does not accept [bracket] quoting as input, so we pre-process\n// [foo] → `foo` (backtick), which the SQLite grammar accepts and normalizes to \"foo\".\n// sqlify with TransactSQL opts then re-emits all identifiers as [foo].\nconst SQLITE_OPT = { database: 'SQLite' }\nconst TSQL_OPT = { database: 'TransactSQL' }\nconst sqlParser = new SqlParserClass()\n\n/** Convert [bracket] identifiers to backtick so the SQLite parser accepts them. */\nfunction bracketsToBackticks(query: string): string {\n  let result = ''\n  let i = 0\n\n  let inSingleQuote = false\n  let inDoubleQuote = false\n  let inBacktick = false\n  let inLineComment = false\n  let inBlockComment = false\n\n  while (i < query.length) {\n    const char = query[i]\n    const next = i + 1 < query.length ? query[i + 1] : ''\n\n    // Handle end of line comment\n    if (inLineComment) {\n      result += char\n      if (char === '\\n') {\n        inLineComment = false\n      }\n      i += 1\n      continue\n    }\n\n    // Handle end of block comment\n    if (inBlockComment) {\n      result += char\n      if (char === '*' && next === '/') {\n        result += next\n        inBlockComment = false\n        i += 2\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle single-quoted strings, preserving content verbatim.\n    if (inSingleQuote) {\n      result += char\n      if (char === \"'\" && next === \"'\") {\n        // Escaped single quote: consume both quotes.\n        result += next\n        i += 2\n      } else if (char === \"'\") {\n        inSingleQuote = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle double-quoted identifiers/strings.\n    if (inDoubleQuote) {\n      result += char\n      if (char === '\"' && next === '\"') {\n        // Escaped double quote: consume both quotes.\n        result += next\n        i += 2\n      } else if (char === '\"') {\n        inDoubleQuote = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // Handle backtick-quoted identifiers.\n    if (inBacktick) {\n      result += char\n      if (char === '`' && next === '`') {\n        // Escaped backtick: consume both backticks.\n        result += next\n        i += 2\n      } else if (char === '`') {\n        inBacktick = false\n        i += 1\n      } else {\n        i += 1\n      }\n      continue\n    }\n\n    // We are not currently inside a string or comment.\n    // Check for start of comments first.\n    if (char === '-' && next === '-') {\n      result += char + next\n      inLineComment = true\n      i += 2\n      continue\n    }\n\n    if (char === '/' && next === '*') {\n      result += char + next\n      inBlockComment = true\n      i += 2\n      continue\n    }\n\n    // Check for start of strings / quoted identifiers.\n    if (char === \"'\") {\n      result += char\n      inSingleQuote = true\n      i += 1\n      continue\n    }\n\n    if (char === '\"') {\n      result += char\n      inDoubleQuote = true\n      i += 1\n      continue\n    }\n\n    if (char === '`') {\n      result += char\n      inBacktick = true\n      i += 1\n      continue\n    }\n\n    // Perform [bracket] → `backtick` replacement only outside literals/comments.\n    // Handle ]] as escaped ] inside bracket-quoted identifiers (like '' in strings).\n    if (char === '[') {\n      let inner = ''\n      let j = i + 1\n      let closed = false\n      while (j < query.length) {\n        if (query[j] === ']') {\n          if (j + 1 < query.length && query[j + 1] === ']') {\n            // Escaped ]] → literal ]\n            inner += ']'\n            j += 2\n          } else {\n            // Closing bracket\n            closed = true\n            j += 1\n            break\n          }\n        } else {\n          inner += query[j]\n          j += 1\n        }\n      }\n      if (closed) {\n        result += '`' + inner + '`'\n        i = j\n        continue\n      }\n      // No matching ']' found — treat as a normal character.\n      result += char\n      i += 1\n      continue\n    }\n\n    // Default: copy character as-is.\n    result += char\n    i += 1\n  }\n\n  return result\n}\n\n/** Build a json_extract(data, path) AST function-call node. */\nfunction makeJsonExtractNode(path: string): object {\n  return {\n    type: 'function',\n    name: { name: [{ type: 'default', value: 'json_extract' }] },\n    args: {\n      type: 'expr_list',\n      value: [\n        { type: 'column_ref', table: null, column: 'data', collate: null },\n        { type: 'single_quote_string', value: path },\n      ],\n    },\n    over: null,\n  }\n}\n\n/**\n * Recursively walk an AST node tree, replacing bare `'$.path'` string-literal\n * nodes with json_extract function-call nodes. Existing json_extract calls are\n * left untouched so shorthand is never double-expanded.\n */\nfunction expandShorthandInAst(node: unknown): unknown {\n  if (node === null || typeof node !== 'object') return node\n\n  const obj = node as Record<string, unknown>\n\n  // Bare shorthand: single_quote_string whose value starts with '$.'\n  if (\n    obj.type === 'single_quote_string' &&\n    typeof obj.value === 'string' &&\n    obj.value.startsWith('$.')\n  ) {\n    return makeJsonExtractNode(obj.value)\n  }\n\n  // Skip args of existing json_extract calls — they are already expanded.\n  if (obj.type === 'function') {\n    const nameArr = (obj.name as Record<string, unknown>)?.name as\n      | Array<Record<string, unknown>>\n      | undefined\n    if (nameArr?.[0]?.value === 'json_extract') return node\n  }\n\n  // Recurse into all child properties.\n  const result: Record<string, unknown> = {}\n  for (const [key, val] of Object.entries(obj)) {\n    result[key] = Array.isArray(val) ? val.map(expandShorthandInAst) : expandShorthandInAst(val)\n  }\n  return result\n}\n\n/**\n * Lowercase non-literal content for case-insensitive comparison.\n * Single-quoted string literals are preserved verbatim.\n */\nfunction lowercaseIdentifiers(query: string): string {\n  const parts = query.split(/(\\'(?:[^\\']|\\'\\')*\\')/g)\n  return parts.map((part, i) => (i % 2 === 0 ? part.toLowerCase() : part)).join('')\n}\n\n/**\n * Normalize a SQL query to a canonical, reusable form.\n *\n * Applies the following transformations:\n * 1. Convert `[bracket]` identifiers to backtick for parser input\n * 2. Parse with the SQLite grammar (strips comments, validates structure)\n * 3. Expand `'$.path'` shorthand to `json_extract(data, '$.path')` via AST walk\n * 4. Re-emit with TransactSQL bracket quoting — all identifiers become `[name]`\n *    and SQL keywords are uppercased\n *\n * The result is valid SQL suitable for reuse. Use `queriesEquivalent` for\n * case-insensitive comparison.\n *\n * @param query - SQL query to normalize\n * @returns Canonical form of the query\n */\nexport function normalizeQuery(query: string): string {\n  const preprocessed: string = bracketsToBackticks(query)\n  const ast: AST | AST[] = sqlParser.astify(preprocessed, SQLITE_OPT)\n  const transformed = Array.isArray(ast) ? ast.map(expandShorthandInAst) : expandShorthandInAst(ast)\n  return sqlParser.sqlify(transformed as AST | AST[], TSQL_OPT)\n}\n\n/**\n * Compare two SQL queries for semantic equivalence.\n *\n * Ignores differences in whitespace, keyword case, identifier case, square\n * bracket quoting, and the `'$.path'` json_extract shorthand. String literal\n * values are case-sensitive (`'Active'` ≠ `'active'`).\n *\n * @param a - First SQL query\n * @param b - Second SQL query\n * @returns true if the queries are semantically equivalent\n */\nexport function queriesEquivalent(a: string, b: string): boolean {\n  return lowercaseIdentifiers(normalizeQuery(a)) === lowercaseIdentifiers(normalizeQuery(b))\n}\n"]}