@ruiapp/rapid-core 0.8.7 → 0.8.8

package/dist/index.js

@@ -5171,10 +5171,293 @@ function replaceModelIndexConditionEntityPropertyWithTableColumn(logger, model,
     };
 }
 
+function generateCreateColumnDDL(queryBuilder, options) {
+    let columnDDL = `ALTER TABLE ${queryBuilder.quoteTable(options)} ADD`;
+    columnDDL += ` ${queryBuilder.quoteObject(options.name)}`;
+    if (options.type === "integer" && options.autoIncrement) {
+        columnDDL += ` serial`;
+    }
+    else {
+        const columnType = pgPropertyTypeColumnMap[options.type];
+        if (!columnType) {
+            throw new Error(`Property type "${options.type}" is not supported.`);
+        }
+        columnDDL += ` ${columnType}`;
+    }
+    if (options.notNull) {
+        columnDDL += " NOT NULL";
+    }
+    if (options.defaultValue) {
+        columnDDL += ` DEFAULT ${options.defaultValue}`;
+    }
+    return columnDDL;
+}
+function generateLinkTableDDL(queryBuilder, options) {
+    let columnDDL = `CREATE TABLE ${queryBuilder.quoteTable({
+        schema: options.linkSchema,
+        tableName: options.linkTableName,
+    })} (`;
+    columnDDL += `id serial not null,`;
+    columnDDL += `${queryBuilder.quoteObject(options.selfIdColumnName)} integer not null,`;
+    columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null);`;
+    return columnDDL;
+}
+function generateTableIndexDDL(queryBuilder, server, model, index) {
+    let indexName = index.name;
+    if (!indexName) {
+        indexName = model.tableName;
+        for (const indexProp of index.properties) {
+            const propCode = lodash.isString(indexProp) ? indexProp : indexProp.code;
+            const property = getEntityPropertyByCode(server, model, propCode);
+            if (!isRelationProperty(property)) {
+                indexName += "_" + property.columnName;
+            }
+            else if (isOneRelationProperty(property)) {
+                indexName += "_" + property.targetIdColumnName;
+            }
+        }
+        indexName += index.unique ? "_uindex" : "_index";
+    }
+    const indexColumns = lodash.map(index.properties, (indexProp) => {
+        let columnName;
+        const propCode = lodash.isString(indexProp) ? indexProp : indexProp.code;
+        const property = getEntityPropertyByCode(server, model, propCode);
+        if (!isRelationProperty(property)) {
+            columnName = property.columnName;
+        }
+        else if (isOneRelationProperty(property)) {
+            columnName = property.targetIdColumnName;
+        }
+        if (lodash.isString(indexProp)) {
+            return columnName;
+        }
+        if (indexProp.order === "desc") {
+            return `${columnName} desc`;
+        }
+        return columnName;
+    });
+    let ddl = `CREATE ${index.unique ? "UNIQUE" : ""} INDEX ${indexName} `;
+    ddl += `ON ${queryBuilder.quoteTable({
+        schema: model.schema,
+        tableName: model.tableName,
+    })} (${indexColumns.join(", ")})`;
+    if (index.conditions) {
+        const logger = server.getLogger();
+        const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(logger, model, index.conditions);
+        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
+    }
+    return ddl;
+}
+class MetaService {
+    #server;
+    constructor(server) {
+        this.#server = server;
+    }
+    async syncDatabaseSchema(applicationConfig) {
+        const server = this.#server;
+        const logger = server.getLogger();
+        logger.info("Synchronizing database schema...");
+        const sqlQueryTableInformations = `SELECT table_schema, table_name, obj_description((table_schema||'.'||quote_ident(table_name))::regclass) as table_description FROM information_schema.tables`;
+        const tablesInDb = await server.queryDatabaseObject(sqlQueryTableInformations);
+        const { queryBuilder } = server;
+        for (const model of applicationConfig.models) {
+            logger.debug(`Checking data table for '${model.namespace}.${model.singularCode}'...`);
+            const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
+            const expectedTableName = model.tableName;
+            const tableInDb = lodash.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName });
+            if (!tableInDb) {
+                await server.queryDatabaseObject(`CREATE TABLE IF NOT EXISTS ${queryBuilder.quoteTable(model)} ()`, []);
+            }
+            if (!tableInDb || tableInDb.table_description != model.name) {
+                await server.tryQueryDatabaseObject(`COMMENT ON TABLE ${queryBuilder.quoteTable(model)} IS ${queryBuilder.formatValueToSqlLiteral(model.name)};`, []);
+            }
+        }
+        const sqlQueryColumnInformations = `SELECT c.table_schema, c.table_name, c.column_name, c.ordinal_position, d.description, c.data_type,  c.udt_name, c.is_nullable, c.column_default, c.character_maximum_length, c.numeric_precision, c.numeric_scale
+      FROM information_schema.columns c
+      INNER JOIN pg_catalog.pg_statio_all_tables st ON (st.schemaname = c.table_schema and st.relname = c.table_name)
+      LEFT JOIN pg_catalog.pg_description d ON (d.objoid = st.relid and d.objsubid = c.ordinal_position);`;
+        const columnsInDb = await server.queryDatabaseObject(sqlQueryColumnInformations, []);
+        for (const model of applicationConfig.models) {
+            logger.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
+            for (const property of model.properties) {
+                let columnDDL = "";
+                if (isRelationProperty(property)) {
+                    if (property.relation === "one") {
+                        const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
+                        if (!targetModel) {
+                            logger.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
+                        }
+                        const columnInDb = lodash.find(columnsInDb, {
+                            table_schema: model.schema || "public",
+                            table_name: model.tableName,
+                            column_name: property.targetIdColumnName,
+                        });
+                        if (!columnInDb) {
+                            columnDDL = generateCreateColumnDDL(queryBuilder, {
+                                schema: model.schema,
+                                tableName: model.tableName,
+                                name: property.targetIdColumnName,
+                                type: "integer",
+                                autoIncrement: false,
+                                notNull: property.required,
+                            });
+                            await server.tryQueryDatabaseObject(columnDDL);
+                        }
+                        if (!columnInDb || columnInDb.description != property.name) {
+                            await server.tryQueryDatabaseObject(`COMMENT ON COLUMN ${queryBuilder.quoteTable(model)}.${queryBuilder.quoteObject(property.targetIdColumnName)} IS ${queryBuilder.formatValueToSqlLiteral(property.name)};`, []);
+                        }
+                    }
+                    else if (property.relation === "many") {
+                        if (property.linkTableName) {
+                            const tableInDb = lodash.find(tablesInDb, {
+                                table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema,
+                                table_name: property.linkTableName,
+                            });
+                            if (!tableInDb) {
+                                columnDDL = generateLinkTableDDL(queryBuilder, {
+                                    linkSchema: property.linkSchema,
+                                    linkTableName: property.linkTableName,
+                                    targetIdColumnName: property.targetIdColumnName,
+                                    selfIdColumnName: property.selfIdColumnName,
+                                });
+                            }
+                            const contraintName = `${property.linkTableName}_pk`;
+                            columnDDL += `ALTER TABLE ${queryBuilder.quoteTable({
+                                schema: property.linkSchema,
+                                tableName: property.linkTableName,
+                            })} ADD CONSTRAINT ${queryBuilder.quoteObject(contraintName)} PRIMARY KEY (id);`;
+                            await server.tryQueryDatabaseObject(columnDDL);
+                        }
+                        else {
+                            const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
+                            if (!targetModel) {
+                                logger.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
+                                continue;
+                            }
+                            const columnInDb = lodash.find(columnsInDb, {
+                                table_schema: targetModel.schema || "public",
+                                table_name: targetModel.tableName,
+                                column_name: property.selfIdColumnName,
+                            });
+                            if (!columnInDb) {
+                                columnDDL = generateCreateColumnDDL(queryBuilder, {
+                                    schema: targetModel.schema,
+                                    tableName: targetModel.tableName,
+                                    name: property.selfIdColumnName || "",
+                                    type: "integer",
+                                    autoIncrement: false,
+                                    notNull: property.required,
+                                });
+                                await server.tryQueryDatabaseObject(columnDDL);
+                            }
+                        }
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                else {
+                    const columnName = property.columnName || property.code;
+                    const columnInDb = lodash.find(columnsInDb, {
+                        table_schema: model.schema || "public",
+                        table_name: model.tableName,
+                        column_name: columnName,
+                    });
+                    if (!columnInDb) {
+                        // create column if not exists
+                        columnDDL = generateCreateColumnDDL(queryBuilder, {
+                            schema: model.schema,
+                            tableName: model.tableName,
+                            name: columnName,
+                            type: property.type,
+                            autoIncrement: property.autoIncrement,
+                            notNull: property.required,
+                            defaultValue: property.defaultValue,
+                        });
+                        await server.tryQueryDatabaseObject(columnDDL);
+                    }
+                    else {
+                        const expectedColumnType = pgPropertyTypeColumnMap[property.type];
+                        if (columnInDb.udt_name !== expectedColumnType) {
+                            const sqlAlterColumnType = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} type ${expectedColumnType}`;
+                            await server.tryQueryDatabaseObject(sqlAlterColumnType);
+                        }
+                        if (property.defaultValue) {
+                            if (!columnInDb.column_default) {
+                                const sqlSetColumnDefault = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} set default ${property.defaultValue}`;
+                                await server.tryQueryDatabaseObject(sqlSetColumnDefault);
+                            }
+                        }
+                        else {
+                            if (columnInDb.column_default && !property.autoIncrement) {
+                                const sqlDropColumnDefault = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} drop default`;
+                                await server.tryQueryDatabaseObject(sqlDropColumnDefault);
+                            }
+                        }
+                        if (property.required) {
+                            if (columnInDb.is_nullable === "YES") {
+                                const sqlSetColumnNotNull = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} set not null`;
+                                await server.tryQueryDatabaseObject(sqlSetColumnNotNull);
+                            }
+                        }
+                        else {
+                            if (columnInDb.is_nullable === "NO") {
+                                const sqlDropColumnNotNull = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} drop not null`;
+                                await server.tryQueryDatabaseObject(sqlDropColumnNotNull);
+                            }
+                        }
+                    }
+                    if (!columnInDb || columnInDb.description != property.name) {
+                        await server.tryQueryDatabaseObject(`COMMENT ON COLUMN ${queryBuilder.quoteTable(model)}.${queryBuilder.quoteObject(property.columnName || property.code)} IS ${queryBuilder.formatValueToSqlLiteral(property.name)};`, []);
+                    }
+                }
+            }
+        }
+        const sqlQueryConstraints = `SELECT table_schema, table_name, constraint_type, constraint_name FROM information_schema.table_constraints WHERE constraint_type = 'PRIMARY KEY';`;
+        const constraintsInDb = await server.queryDatabaseObject(sqlQueryConstraints);
+        for (const model of applicationConfig.models) {
+            const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
+            const expectedTableName = model.tableName;
+            const expectedContraintName = `${expectedTableName}_pk`;
+            logger.debug(`Checking pk for '${expectedTableSchema}.${expectedTableName}'...`);
+            const constraintInDb = lodash.find(constraintsInDb, {
+                table_schema: expectedTableSchema,
+                table_name: expectedTableName,
+                constraint_type: "PRIMARY KEY",
+                constraint_name: expectedContraintName,
+            });
+            if (!constraintInDb) {
+                await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} ADD CONSTRAINT ${queryBuilder.quoteObject(expectedContraintName)} PRIMARY KEY (id);`, []);
+            }
+        }
+        // generate indexes
+        for (const model of applicationConfig.models) {
+            if (!model.indexes || !model.indexes.length) {
+                continue;
+            }
+            logger.debug(`Creating indexes of table ${queryBuilder.quoteTable(model)}`);
+            for (const index of model.indexes) {
+                const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
+                await server.tryQueryDatabaseObject(sqlCreateIndex, []);
+            }
+        }
+    }
+}
+
 /**
  * Meta manager plugin
  */
 class MetaManager {
+    #metaService;
+    #syncDatabaseSchemaOnLoaded;
+    constructor(options) {
+        if (!options) {
+            options = {
+                syncDatabaseSchemaOnLoaded: true,
+            };
+        }
+        this.#syncDatabaseSchemaOnLoaded = options.syncDatabaseSchemaOnLoaded;
+    }
     get code() {
         return "metaManager";
     }
@@ -5212,8 +5495,14 @@ class MetaManager {
             logger.crit("Failed to load meta of models.", { error });
         }
     }
+    async configureServices(server, applicationConfig) {
+        this.#metaService = new MetaService(server);
+        server.registerService("metaService", this.#metaService);
+    }
     async onApplicationLoaded(server, applicationConfig) {
-        await syncDatabaseSchema(server, applicationConfig);
+        if (this.#syncDatabaseSchemaOnLoaded) {
+            await this.#metaService.syncDatabaseSchema(applicationConfig);
+        }
     }
 }
 async function handleEntityCreateEvent(server, sender, payload) {
@@ -5281,271 +5570,6 @@ function listDataDictionaries(server) {
     return dataDictionaryManager.findEntities({
         properties: properties.map((item) => item.code),
     });
-}
-async function syncDatabaseSchema(server, applicationConfig) {
-    const logger = server.getLogger();
-    logger.info("Synchronizing database schema...");
-    const sqlQueryTableInformations = `SELECT table_schema, table_name, obj_description((table_schema||'.'||quote_ident(table_name))::regclass) as table_description FROM information_schema.tables`;
-    const tablesInDb = await server.queryDatabaseObject(sqlQueryTableInformations);
-    const { queryBuilder } = server;
-    for (const model of applicationConfig.models) {
-        logger.debug(`Checking data table for '${model.namespace}.${model.singularCode}'...`);
-        const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
-        const expectedTableName = model.tableName;
-        const tableInDb = lodash.find(tablesInDb, { table_schema: expectedTableSchema, table_name: expectedTableName });
-        if (!tableInDb) {
-            await server.queryDatabaseObject(`CREATE TABLE IF NOT EXISTS ${queryBuilder.quoteTable(model)} ()`, []);
-        }
-        if (!tableInDb || tableInDb.table_description != model.name) {
-            await server.tryQueryDatabaseObject(`COMMENT ON TABLE ${queryBuilder.quoteTable(model)} IS ${queryBuilder.formatValueToSqlLiteral(model.name)};`, []);
-        }
-    }
-    const sqlQueryColumnInformations = `SELECT c.table_schema, c.table_name, c.column_name, c.ordinal_position, d.description, c.data_type,  c.udt_name, c.is_nullable, c.column_default, c.character_maximum_length, c.numeric_precision, c.numeric_scale
-    FROM information_schema.columns c
-    INNER JOIN pg_catalog.pg_statio_all_tables st ON (st.schemaname = c.table_schema and st.relname = c.table_name)
-    LEFT JOIN pg_catalog.pg_description d ON (d.objoid = st.relid and d.objsubid = c.ordinal_position);`;
-    const columnsInDb = await server.queryDatabaseObject(sqlQueryColumnInformations, []);
-    for (const model of applicationConfig.models) {
-        logger.debug(`Checking data columns for '${model.namespace}.${model.singularCode}'...`);
-        for (const property of model.properties) {
-            let columnDDL = "";
-            if (isRelationProperty(property)) {
-                if (property.relation === "one") {
-                    const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
-                    if (!targetModel) {
-                        logger.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
-                    }
-                    const columnInDb = lodash.find(columnsInDb, {
-                        table_schema: model.schema || "public",
-                        table_name: model.tableName,
-                        column_name: property.targetIdColumnName,
-                    });
-                    if (!columnInDb) {
-                        columnDDL = generateCreateColumnDDL(queryBuilder, {
-                            schema: model.schema,
-                            tableName: model.tableName,
-                            name: property.targetIdColumnName,
-                            type: "integer",
-                            autoIncrement: false,
-                            notNull: property.required,
-                        });
-                        await server.tryQueryDatabaseObject(columnDDL);
-                    }
-                    if (!columnInDb || columnInDb.description != property.name) {
-                        await server.tryQueryDatabaseObject(`COMMENT ON COLUMN ${queryBuilder.quoteTable(model)}.${queryBuilder.quoteObject(property.targetIdColumnName)} IS ${queryBuilder.formatValueToSqlLiteral(property.name)};`, []);
-                    }
-                }
-                else if (property.relation === "many") {
-                    if (property.linkTableName) {
-                        const tableInDb = lodash.find(tablesInDb, {
-                            table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema,
-                            table_name: property.linkTableName,
-                        });
-                        if (!tableInDb) {
-                            columnDDL = generateLinkTableDDL(queryBuilder, {
-                                linkSchema: property.linkSchema,
-                                linkTableName: property.linkTableName,
-                                targetIdColumnName: property.targetIdColumnName,
-                                selfIdColumnName: property.selfIdColumnName,
-                            });
-                        }
-                        const contraintName = `${property.linkTableName}_pk`;
-                        columnDDL += `ALTER TABLE ${queryBuilder.quoteTable({
-                            schema: property.linkSchema,
-                            tableName: property.linkTableName,
-                        })} ADD CONSTRAINT ${queryBuilder.quoteObject(contraintName)} PRIMARY KEY (id);`;
-                        await server.tryQueryDatabaseObject(columnDDL);
-                    }
-                    else {
-                        const targetModel = applicationConfig.models.find((item) => item.singularCode === property.targetSingularCode);
-                        if (!targetModel) {
-                            logger.warn(`Cannot find target model with singular code "${property.targetSingularCode}".`);
-                            continue;
-                        }
-                        const columnInDb = lodash.find(columnsInDb, {
-                            table_schema: targetModel.schema || "public",
-                            table_name: targetModel.tableName,
-                            column_name: property.selfIdColumnName,
-                        });
-                        if (!columnInDb) {
-                            columnDDL = generateCreateColumnDDL(queryBuilder, {
-                                schema: targetModel.schema,
-                                tableName: targetModel.tableName,
-                                name: property.selfIdColumnName || "",
-                                type: "integer",
-                                autoIncrement: false,
-                                notNull: property.required,
-                            });
-                            await server.tryQueryDatabaseObject(columnDDL);
-                        }
-                    }
-                }
-                else {
-                    continue;
-                }
-            }
-            else {
-                const columnName = property.columnName || property.code;
-                const columnInDb = lodash.find(columnsInDb, {
-                    table_schema: model.schema || "public",
-                    table_name: model.tableName,
-                    column_name: columnName,
-                });
-                if (!columnInDb) {
-                    // create column if not exists
-                    columnDDL = generateCreateColumnDDL(queryBuilder, {
-                        schema: model.schema,
-                        tableName: model.tableName,
-                        name: columnName,
-                        type: property.type,
-                        autoIncrement: property.autoIncrement,
-                        notNull: property.required,
-                        defaultValue: property.defaultValue,
-                    });
-                    await server.tryQueryDatabaseObject(columnDDL);
-                }
-                else {
-                    const expectedColumnType = pgPropertyTypeColumnMap[property.type];
-                    if (columnInDb.udt_name !== expectedColumnType) {
-                        const sqlAlterColumnType = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} type ${expectedColumnType}`;
-                        await server.tryQueryDatabaseObject(sqlAlterColumnType);
-                    }
-                    if (property.defaultValue) {
-                        if (!columnInDb.column_default) {
-                            const sqlSetColumnDefault = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} set default ${property.defaultValue}`;
-                            await server.tryQueryDatabaseObject(sqlSetColumnDefault);
-                        }
-                    }
-                    else {
-                        if (columnInDb.column_default && !property.autoIncrement) {
-                            const sqlDropColumnDefault = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} drop default`;
-                            await server.tryQueryDatabaseObject(sqlDropColumnDefault);
-                        }
-                    }
-                    if (property.required) {
-                        if (columnInDb.is_nullable === "YES") {
-                            const sqlSetColumnNotNull = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} set not null`;
-                            await server.tryQueryDatabaseObject(sqlSetColumnNotNull);
-                        }
-                    }
-                    else {
-                        if (columnInDb.is_nullable === "NO") {
-                            const sqlDropColumnNotNull = `alter table ${queryBuilder.quoteTable(model)} alter column ${queryBuilder.quoteObject(columnName)} drop not null`;
-                            await server.tryQueryDatabaseObject(sqlDropColumnNotNull);
-                        }
-                    }
-                }
-                if (!columnInDb || columnInDb.description != property.name) {
-                    await server.tryQueryDatabaseObject(`COMMENT ON COLUMN ${queryBuilder.quoteTable(model)}.${queryBuilder.quoteObject(property.columnName || property.code)} IS ${queryBuilder.formatValueToSqlLiteral(property.name)};`, []);
-                }
-            }
-        }
-    }
-    const sqlQueryConstraints = `SELECT table_schema, table_name, constraint_type, constraint_name FROM information_schema.table_constraints WHERE constraint_type = 'PRIMARY KEY';`;
-    const constraintsInDb = await server.queryDatabaseObject(sqlQueryConstraints);
-    for (const model of applicationConfig.models) {
-        const expectedTableSchema = model.schema || server.databaseConfig.dbDefaultSchema;
-        const expectedTableName = model.tableName;
-        const expectedContraintName = `${expectedTableName}_pk`;
-        logger.debug(`Checking pk for '${expectedTableSchema}.${expectedTableName}'...`);
-        const constraintInDb = lodash.find(constraintsInDb, {
-            table_schema: expectedTableSchema,
-            table_name: expectedTableName,
-            constraint_type: "PRIMARY KEY",
-            constraint_name: expectedContraintName,
-        });
-        if (!constraintInDb) {
-            await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} ADD CONSTRAINT ${queryBuilder.quoteObject(expectedContraintName)} PRIMARY KEY (id);`, []);
-        }
-    }
-    // generate indexes
-    for (const model of applicationConfig.models) {
-        if (!model.indexes || !model.indexes.length) {
-            continue;
-        }
-        logger.debug(`Creating indexes of table ${queryBuilder.quoteTable(model)}`);
-        for (const index of model.indexes) {
-            const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
-            await server.tryQueryDatabaseObject(sqlCreateIndex, []);
-        }
-    }
-}
-function generateCreateColumnDDL(queryBuilder, options) {
-    let columnDDL = `ALTER TABLE ${queryBuilder.quoteTable(options)} ADD`;
-    columnDDL += ` ${queryBuilder.quoteObject(options.name)}`;
-    if (options.type === "integer" && options.autoIncrement) {
-        columnDDL += ` serial`;
-    }
-    else {
-        const columnType = pgPropertyTypeColumnMap[options.type];
-        if (!columnType) {
-            throw new Error(`Property type "${options.type}" is not supported.`);
-        }
-        columnDDL += ` ${columnType}`;
-    }
-    if (options.notNull) {
-        columnDDL += " NOT NULL";
-    }
-    if (options.defaultValue) {
-        columnDDL += ` DEFAULT ${options.defaultValue}`;
-    }
-    return columnDDL;
-}
-function generateLinkTableDDL(queryBuilder, options) {
-    let columnDDL = `CREATE TABLE ${queryBuilder.quoteTable({
-        schema: options.linkSchema,
-        tableName: options.linkTableName,
-    })} (`;
-    columnDDL += `id serial not null,`;
-    columnDDL += `${queryBuilder.quoteObject(options.selfIdColumnName)} integer not null,`;
-    columnDDL += `${queryBuilder.quoteObject(options.targetIdColumnName)} integer not null);`;
-    return columnDDL;
-}
-function generateTableIndexDDL(queryBuilder, server, model, index) {
-    let indexName = index.name;
-    if (!indexName) {
-        indexName = model.tableName;
-        for (const indexProp of index.properties) {
-            const propCode = lodash.isString(indexProp) ? indexProp : indexProp.code;
-            const property = getEntityPropertyByCode(server, model, propCode);
-            if (!isRelationProperty(property)) {
-                indexName += "_" + property.columnName;
-            }
-            else if (isOneRelationProperty(property)) {
-                indexName += "_" + property.targetIdColumnName;
-            }
-        }
-        indexName += index.unique ? "_uindex" : "_index";
-    }
-    const indexColumns = lodash.map(index.properties, (indexProp) => {
-        let columnName;
-        const propCode = lodash.isString(indexProp) ? indexProp : indexProp.code;
-        const property = getEntityPropertyByCode(server, model, propCode);
-        if (!isRelationProperty(property)) {
-            columnName = property.columnName;
-        }
-        else if (isOneRelationProperty(property)) {
-            columnName = property.targetIdColumnName;
-        }
-        if (lodash.isString(indexProp)) {
-            return columnName;
-        }
-        if (indexProp.order === "desc") {
-            return `${columnName} desc`;
-        }
-        return columnName;
-    });
-    let ddl = `CREATE ${index.unique ? "UNIQUE" : ""} INDEX ${indexName} `;
-    ddl += `ON ${queryBuilder.quoteTable({
-        schema: model.schema,
-        tableName: model.tableName,
-    })} (${indexColumns.join(", ")})`;
-    if (index.conditions) {
-        const logger = server.getLogger();
-        const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(logger, model, index.conditions);
-        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
-    }
-    return ddl;
 }
 
 function mergeInput(defaultInput, input, fixedInput) {

package/dist/plugins/metaManage/MetaManagePlugin.d.ts

@@ -3,7 +3,12 @@
  */
 import { RpdApplicationConfig } from "../../types";
 import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
+export type MetaManagerInitOptions = {
+    syncDatabaseSchemaOnLoaded?: boolean;
+};
 declare class MetaManager implements RapidPlugin {
+    #private;
+    constructor(options?: MetaManagerInitOptions);
     get code(): string;
     get description(): string;
     get extendingAbilities(): RpdServerPluginExtendingAbilities[];
@@ -12,6 +17,7 @@ declare class MetaManager implements RapidPlugin {
     registerActionHandlers(server: IRpdServer): Promise<any>;
     registerEventHandlers(server: IRpdServer): Promise<any>;
     configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureServices(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
 }
 export default MetaManager;

package/dist/plugins/metaManage/services/MetaService.d.ts

@@ -0,0 +1,7 @@
+import { IRpdServer } from "../../../core/server";
+import { RpdApplicationConfig } from "../../../types";
+export default class MetaService {
+    #private;
+    constructor(server: IRpdServer);
+    syncDatabaseSchema(applicationConfig: RpdApplicationConfig): Promise<void>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",