@peers-app/peers-sdk 0.1.4

package/dist/data/orm/sql.data-source.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLDataSource = void 0;
+exports.jsValueToSqlValue = jsValueToSqlValue;
+exports.sqlValueToJsValue = sqlValueToJsValue;
+exports.globalDefaultValues = globalDefaultValues;
+const utils_1 = require("../../utils");
+const serial_json_1 = require("../../serial-json");
+const data_query_1 = require("./data-query");
+const data_query_sqlite_1 = require("./data-query.sqlite");
+const types_1 = require("./types");
+class SQLDataSource {
+    db;
+    metaData;
+    schema;
+    tableName;
+    primaryKeyName;
+    constructor(db, metaData, schema = (0, types_1.fieldsToSchema)(metaData.fields)) {
+        this.db = db;
+        this.metaData = metaData;
+        this.schema = schema;
+        this.tableName = (0, utils_1.getFullTableName)(metaData);
+        this.primaryKeyName = metaData.primaryKeyName;
+        const primaryKeyIsValid = metaData.fields.find(f => f.name === metaData.primaryKeyName);
+        if (!primaryKeyIsValid) {
+            throw new Error(`Table "${this.tableName}", primary key "${metaData.primaryKeyName}" is not a valid field name`);
+        }
+    }
+    buildTableSql() {
+        let fieldsSql = [];
+        for (const field of this.metaData.fields) {
+            let sqlType = "";
+            switch (field.type) {
+                case 'id':
+                    // consider using: `id TEXT NOT NULL CHECK (length(id) = 25)
+                    sqlType = 'TEXT';
+                    break;
+                case 'string':
+                    sqlType = 'TEXT';
+                    break;
+                case 'number':
+                    sqlType = 'REAL';
+                    break;
+                case 'boolean':
+                    sqlType = 'INTEGER';
+                    break;
+                case 'Date':
+                    sqlType = 'TEXT';
+                    break;
+                case 'object':
+                    sqlType = 'TEXT';
+                    break;
+                default:
+                    sqlType = 'TEXT';
+            }
+            let options = field.optional ? 'NULL' : 'NOT NULL';
+            if (field.name === this.metaData.primaryKeyName) {
+                options += ' PRIMARY KEY';
+            }
+            fieldsSql.push(`"${field.name}" ${sqlType} ${options}`);
+        }
+        // const fields = this.dataType.fields.map(f => `${f.name} ${f.type}`).join(', ');
+        const fields = fieldsSql.join(',\n');
+        const sql = [
+            `CREATE TABLE IF NOT EXISTS "${this.tableName}" (`,
+            ` ${fields}`,
+            `) WITHOUT ROWID`,
+        ].join('\n');
+        return sql;
+    }
+    async ensureTableAndIndexesExist() {
+        // create table if not exists
+        const sql = this.buildTableSql();
+        await this.db.exec(sql, []);
+        const indexNames = [];
+        // create indexes if they don't exist
+        if (this.metaData.indexes) {
+            for (const index of this.metaData.indexes) {
+                let fieldNames = '';
+                const fields = index.fields.map(f => {
+                    if (typeof f === 'string') {
+                        fieldNames += '_' + f;
+                        return f;
+                    }
+                    else {
+                        fieldNames += '_' + f.name;
+                        return `${f.name} ${f.order}`;
+                    }
+                }).join(', ');
+                const hash = (0, utils_1.simpleHash)(JSON.stringify(index));
+                const unique = index.unique ? 'UNIQUE' : '';
+                const indexName = `${this.tableName}_${fieldNames}_${hash}`;
+                indexNames.push(indexName);
+                const sql = `CREATE ${unique} INDEX IF NOT EXISTS "${indexName}" ON "${this.tableName}"(${fields});`;
+                try {
+                    await this.db.exec(sql, []);
+                }
+                catch (e) {
+                    console.error(`Error creating index "${indexName}" on table "${this.tableName}": ${String(e)}`);
+                }
+            }
+        }
+        // remove indexes that are no longer specified in the schema
+        const existingIndexes = (await this.db.all(`PRAGMA index_list("${this.tableName}")`, [])) || [];
+        for (const existingIndex of existingIndexes) {
+            const indexName = existingIndex.name;
+            if (!indexNames.includes(indexName) && !indexName.startsWith('sqlite_autoindex_')) {
+                console.log(`Dropping index "${indexName}" because it's no longer in the schema.`);
+                const sql = `DROP INDEX IF EXISTS "${indexName}"`;
+                await this.db.exec(sql, []);
+            }
+        }
+    }
+    async ensureTableIsNewest() {
+        const now = new Date();
+        await this.ensureTableAndIndexesExist();
+        let newestTableDef = this.buildTableSql();
+        newestTableDef = newestTableDef.replace(/CREATE TABLE IF NOT EXISTS/, 'CREATE TABLE');
+        const sqlGetTableRecord = `SELECT * FROM sqlite_master WHERE type = 'table' AND name = '${this.tableName}'`;
+        const table = await this.db.get(sqlGetTableRecord, []);
+        const existingTableDef = table?.sql || '';
+        if (newestTableDef !== existingTableDef) {
+            console.log(`Table "${this.tableName}" is out of date, updating...`);
+            // rename table
+            const tempTableName = this.tableName + `_old_${now.getTime()}`;
+            const renameSql = `ALTER TABLE "${this.tableName}" RENAME TO "${tempTableName}"`;
+            await this.db.exec(renameSql, []);
+            // create new table
+            await this.ensureTableAndIndexesExist();
+            // sql query to copy existing data and set new required fields to default values
+            const defaults = this.initRecord();
+            const fieldsInsert = this.metaData.fields.map(f => `"${f.name}"`).join(', ');
+            const fieldsSelect = this.metaData.fields.map(f => {
+                const existingField = existingTableDef.includes(`"${f.name}"`);
+                if (existingField && f.optional) {
+                    return `"${f.name}"`;
+                }
+                let defaultValue = defaults[f.name];
+                if (defaultValue === undefined) {
+                    defaultValue = globalDefaultValues(f);
+                }
+                defaultValue = jsValueToSqlValue(defaultValue, true);
+                if (existingField && !f.optional) {
+                    return `CASE WHEN "${f.name}" IS NULL THEN '${defaultValue}' ELSE "${f.name}" END as "${f.name}"`;
+                }
+                if (!existingField && !f.optional) {
+                    return `'${defaultValue}' as "${f.name}"`;
+                }
+                return `NULL as "${f.name}"`;
+            }).join(', ');
+            const insertSql = `INSERT INTO "${this.tableName}"(${fieldsInsert}) SELECT ${fieldsSelect} FROM "${tempTableName}"`;
+            await this.db.exec(insertSql, []);
+            // drop old table
+            const dropSql = `DROP TABLE IF EXISTS "${tempTableName}"`;
+            await this.db.exec(dropSql, []);
+            return true;
+        }
+        return false;
+    }
+    tableBuild;
+    async initTable(force = false) {
+        if (!this.tableBuild || force) {
+            this.tableBuild = this.ensureTableIsNewest();
+        }
+        return this.tableBuild;
+    }
+    async get(id) {
+        let record;
+        await this.initTable();
+        const sqlRecord = await this.db.get(`SELECT * FROM "${this.tableName}" WHERE ${this.metaData.primaryKeyName} = ?`, [id]);
+        record = this.sqlRecordToJsRecord(sqlRecord);
+        return record;
+    }
+    async list(filter = {}, opts = {}) {
+        let dataQuery = new data_query_1.DataQuery(this, {
+            filter: filter,
+            ...opts,
+        });
+        await this.initTable();
+        const sqlQuery = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(dataQuery);
+        const records = await this.db.all(sqlQuery, []);
+        return records.map((r) => this.sqlRecordToJsRecord(r));
+    }
+    ;
+    async count(filter = {}) {
+        let dataQuery = new data_query_1.DataQuery(this, {
+            filter: filter,
+        });
+        await this.initTable();
+        let sqlQuery = (0, data_query_sqlite_1.dataQueryToSqliteQuery)(dataQuery);
+        sqlQuery = sqlQuery.replace('SELECT\n  *\n', 'SELECT COUNT(*) as cnt\n');
+        const cnt = await this.db.get(sqlQuery, []);
+        return cnt['cnt'];
+    }
+    ;
+    cursor(filter = {}, opts = {}) {
+        return (0, data_query_1.dataSourceCursor)(this, filter, opts);
+    }
+    async findOne(filter = {}, opts = {}) {
+        const query = new data_query_1.DataQuery(this, { filter });
+        query.pageSize = opts?.enforceUnique ? 2 : 1;
+        const records = await query.list();
+        if (opts?.enforceUnique && records.length > 1) {
+            throw new Error(`Matched more than one record for ${this.tableName} with query ${JSON.stringify(query)}`);
+        }
+        return records[0];
+    }
+    async save(record) {
+        await this.initTable();
+        let newRecord = true;
+        const primaryKey = record[this.metaData.primaryKeyName];
+        if (primaryKey) {
+            const existingRecord = await this.db.get(`SELECT "${this.metaData.primaryKeyName}" FROM "${this.tableName}" WHERE ${this.metaData.primaryKeyName} = ?`, [primaryKey]);
+            if (existingRecord) {
+                newRecord = false;
+            }
+        }
+        if (newRecord) {
+            return await this.insert(record);
+        }
+        else {
+            return await this.update(record);
+        }
+    }
+    sqlRecordToJsRecord(record) {
+        if (record) {
+            for (const field of this.metaData.fields) {
+                const fieldValue = record[field.name];
+                if (fieldValue === undefined || fieldValue === null) {
+                    delete record[field.name];
+                }
+                else {
+                    record[field.name] =
+                        sqlValueToJsValue(record[field.name], field.type, field.isArray ?? false);
+                }
+            }
+        }
+        return record;
+    }
+    async insert(record) {
+        await this.initTable();
+        if (!record[this.metaData.primaryKeyName]) {
+            // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
+            record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
+        }
+        // validate data
+        try {
+            this.schema.parse(record);
+        }
+        catch (e) {
+            throw new Error(`Validation on insert failed for ${this.tableName}: ${e}`);
+        }
+        const fields = this.metaData.fields.map(field => `"${field.name}"`).join(', ');
+        const values = this.metaData.fields.map(field => jsValueToSqlValue(record[field.name]));
+        const placeholders = values.map(v => '?').join(', ');
+        const sql = `INSERT INTO "${this.tableName}"(${fields}) VALUES(${placeholders})`;
+        await this.db.exec(sql, values);
+        return record;
+    }
+    async update(record) {
+        await this.initTable();
+        if (!record[this.metaData.primaryKeyName]) {
+            // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
+            record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
+        }
+        // validate data
+        this.schema.parse(record);
+        const primaryKey = record[this.metaData.primaryKeyName];
+        const fields = this.metaData.fields.map(field => {
+            if (field.name === this.metaData.primaryKeyName)
+                return;
+            return `"${field.name}" = ?`;
+        }).filter(v => v !== undefined).join(',\n');
+        const values = this.metaData.fields.map(field => {
+            if (field.name === this.metaData.primaryKeyName)
+                return;
+            return jsValueToSqlValue(record[field.name]);
+        }).filter(v => v !== undefined);
+        const sql = [
+            `UPDATE "${this.tableName}"`,
+            `SET ${fields}`,
+            `WHERE "${this.metaData.primaryKeyName}" = ?`,
+        ].join('\n');
+        await this.db.exec(sql, [...values, primaryKey]);
+        return record;
+    }
+    async delete(idOrRecord) {
+        await this.initTable();
+        const primaryKey = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.metaData.primaryKeyName];
+        const sql = `DELETE FROM "${this.tableName}" WHERE "${this.metaData.primaryKeyName}" = ?`;
+        await this.db.exec(sql, [primaryKey]);
+    }
+    async dropTableIfExists() {
+        const sql = `DROP TABLE IF EXISTS "${this.tableName}"`;
+        await this.db.exec(sql, []);
+        this.tableBuild = undefined;
+    }
+    async clearTable() {
+        await this.initTable();
+        const sql = `DELETE FROM "${this.tableName}"`;
+        await this.db.exec(sql, []);
+    }
+    initRecord(data = {}) {
+        const defaults = {};
+        for (const field of this.metaData.fields) {
+            const zodField = this.schema.shape[field.name];
+            const value = zodField.safeParse(data[field.name]);
+            if (value.success) {
+                // @ts-ignore
+                defaults[field.name] = value.data;
+            }
+        }
+        return { ...defaults, ...data };
+    }
+}
+exports.SQLDataSource = SQLDataSource;
+function jsValueToSqlValue(value, escapeQuote = false) {
+    if (value === undefined)
+        return null;
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'object') {
+        return (0, serial_json_1.toJSONString)(value);
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (typeof value === 'string' && escapeQuote) {
+        return value.replace(/'/g, "''");
+    }
+    return value;
+}
+function sqlValueToJsValue(value, fieldType, isArray) {
+    if (value === null)
+        return undefined;
+    if (value === undefined)
+        return undefined;
+    if (isArray) {
+        return JSON.parse(value);
+    }
+    if (fieldType === 'Date') {
+        return new Date(value);
+    }
+    if (fieldType === 'object') {
+        return (0, serial_json_1.fromJSONString)(value);
+    }
+    if (fieldType === 'boolean') {
+        return value === 1;
+    }
+    if (fieldType === 'string') {
+        return String(value);
+    }
+    if (fieldType === 'number') {
+        return Number(value);
+    }
+    return value;
+}
+function globalDefaultValues(field) {
+    const fieldType = field.type;
+    const isArray = field.isArray ?? false;
+    if (isArray) {
+        return [];
+    }
+    switch (fieldType) {
+        case 'Date':
+            return new Date(0);
+        case 'object':
+            return {};
+        case 'boolean':
+            return false;
+        case 'string':
+            return '';
+        case 'number':
+            return 0;
+        default:
+            return '';
+    }
+}

package/dist/data/orm/sql.data-source.test.d.ts

@@ -0,0 +1 @@
+export {};