sonamu 0.2.47 → 0.2.48

package/dist/{chunk-5VT5JTY4.js → chunk-76VBQWGE.js}

@@ -4796,6 +4796,7 @@ var SonamuClass = class {
     this._dbConfig = null;
     this._syncer = null;
     this._config = null;
+    this._secrets = null;
   }
   set apiRootPath(apiRootPath) {
     this._apiRootPath = apiRootPath;
@@ -4836,6 +4837,12 @@ var SonamuClass = class {
     }
     return this._config;
   }
+  set secrets(secrets) {
+    this._secrets = secrets;
+  }
+  get secrets() {
+    return this._secrets;
+  }
   async init(doSilent = false, enableSync = true, apiRootPath) {
     if (this.isInitialized) {
       return;
@@ -4843,12 +4850,18 @@ var SonamuClass = class {
     !doSilent && console.time(_chalk2.default.cyan("Sonamu.init"));
     this.apiRootPath = await _asyncNullishCoalesce(apiRootPath, async () => ( await findApiRootPath()));
     const configPath = _path2.default.join(this.apiRootPath, "sonamu.config.json");
+    const secretsPath = _path2.default.join(this.apiRootPath, "sonamu.secrets.json");
     if (_fsextra2.default.existsSync(configPath) === false) {
       throw new Error(`Cannot find sonamu.config.json in ${configPath}`);
     }
     this.config = JSON.parse(
       _fsextra2.default.readFileSync(configPath).toString()
     );
+    if (_fsextra2.default.existsSync(secretsPath)) {
+      this.secrets = JSON.parse(
+        _fsextra2.default.readFileSync(secretsPath).toString()
+      );
+    }
     this.dbConfig = await DB.readKnexfile();
     !doSilent && console.log(_chalk2.default.green("DB Config Loaded!"));
     attachOnDuplicateUpdate();
@@ -7177,10 +7190,13 @@ ${onlyTs.map((f) => f.name).join("\n")}`
 
 
 
+
+var _fs = require('fs');
 var FixtureManagerClass = class {
   constructor() {
     this._tdb = null;
     this._fdb = null;
+    this.dependencyGraph = /* @__PURE__ */ new Map();
   }
   set tdb(tdb) {
     this._tdb = tdb;
@@ -7357,6 +7373,305 @@ var FixtureManagerClass = class {
     }
     await BaseModel.destroy();
   }
+  async getFixtures(sourceDBName, targetDBName, searchOptions) {
+    const sourceDB = _knex2.default.call(void 0, Sonamu.dbConfig[sourceDBName]);
+    const targetDB = _knex2.default.call(void 0, Sonamu.dbConfig[targetDBName]);
+    const { entityId, field, value, searchType } = searchOptions;
+    const entity = EntityManager.get(entityId);
+    const column = _optionalChain([entity, 'access', _89 => _89.props, 'access', _90 => _90.find, 'call', _91 => _91((prop) => prop.name === field), 'optionalAccess', _92 => _92.type]) === "relation" ? `${field}_id` : field;
+    let query = sourceDB(entity.table);
+    if (searchType === "equals") {
+      query = query.where(column, value);
+    } else if (searchType === "like") {
+      query = query.where(column, "like", `%${value}%`);
+    }
+    const rows = await query;
+    if (rows.length === 0) {
+      throw new Error("No records found");
+    }
+    const visitedEntities = /* @__PURE__ */ new Set();
+    const records = [];
+    for (const row of rows) {
+      const initialRecordsLength = records.length;
+      await this.createFixtureRecord(entity, row, visitedEntities, records);
+      const currentFixtureRecord = records.find(
+        (r) => r.fixtureId === `${entityId}#${row.id}`
+      );
+      if (currentFixtureRecord) {
+        currentFixtureRecord.fetchedRecords = records.filter((r) => r.fixtureId !== currentFixtureRecord.fixtureId).slice(initialRecordsLength).map((r) => r.fixtureId);
+      }
+    }
+    for await (const record of records) {
+      const entity2 = EntityManager.get(record.entityId);
+      const rows2 = [];
+      const row = await targetDB(entity2.table).where("id", record.id).first();
+      if (row) {
+        await this.createFixtureRecord(
+          entity2,
+          row,
+          /* @__PURE__ */ new Set(),
+          rows2,
+          true,
+          targetDB
+        );
+        record.target = rows2[0];
+      }
+    }
+    return records;
+  }
+  async createFixtureRecord(entity, row, visitedEntities, records, singleRecord = false, _db) {
+    const fixtureId = `${entity.id}#${row.id}`;
+    if (visitedEntities.has(fixtureId)) {
+      return;
+    }
+    visitedEntities.add(fixtureId);
+    const record = {
+      fixtureId,
+      entityId: entity.id,
+      id: row.id,
+      columns: {},
+      fetchedRecords: [],
+      belongsRecords: []
+    };
+    for (const prop of entity.props) {
+      if (isVirtualProp(prop)) {
+        continue;
+      }
+      record.columns[prop.name] = {
+        prop,
+        value: row[prop.name]
+      };
+      const db = _nullishCoalesce(_db, () => ( BaseModel.getDB("w")));
+      if (isManyToManyRelationProp(prop)) {
+        const relatedEntity = EntityManager.get(prop.with);
+        const throughTable = prop.joinTable;
+        const fromColumn = `${_inflection2.default.singularize(entity.table)}_id`;
+        const toColumn = `${_inflection2.default.singularize(relatedEntity.table)}_id`;
+        const relatedIds = await db(throughTable).where(fromColumn, row.id).pluck(toColumn);
+        record.columns[prop.name].value = relatedIds;
+      } else if (isHasManyRelationProp(prop)) {
+        const relatedEntity = EntityManager.get(prop.with);
+        const relatedIds = await db(relatedEntity.table).where(prop.joinColumn, row.id).pluck("id");
+        record.columns[prop.name].value = relatedIds;
+      } else if (isOneToOneRelationProp(prop) && !prop.hasJoinColumn) {
+        const relatedEntity = EntityManager.get(prop.with);
+        const relatedProp = relatedEntity.props.find(
+          (p) => p.type === "relation" && p.with === entity.id
+        );
+        if (relatedProp) {
+          const relatedRow = await db(relatedEntity.table).where("id", row.id).first();
+          record.columns[prop.name].value = _optionalChain([relatedRow, 'optionalAccess', _93 => _93.id]);
+        }
+      } else if (isRelationProp(prop)) {
+        const relatedId = row[`${prop.name}_id`];
+        record.columns[prop.name].value = relatedId;
+        if (relatedId) {
+          record.belongsRecords.push(`${prop.with}#${relatedId}`);
+        }
+        if (!singleRecord && relatedId) {
+          const relatedEntity = EntityManager.get(prop.with);
+          const relatedRow = await db(relatedEntity.table).where("id", relatedId).first();
+          if (relatedRow) {
+            await this.createFixtureRecord(
+              relatedEntity,
+              relatedRow,
+              visitedEntities,
+              records,
+              singleRecord,
+              _db
+            );
+          }
+        }
+      }
+    }
+    records.push(record);
+  }
+  async insertFixtures(dbName, fixtures) {
+    this.buildDependencyGraph(fixtures);
+    const insertionOrder = this.getInsertionOrder();
+    const db = _knex2.default.call(void 0, Sonamu.dbConfig[dbName]);
+    await db.transaction(async (trx) => {
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 0`);
+      for (const fixtureId of insertionOrder) {
+        const fixture = fixtures.find((f) => f.fixtureId === fixtureId);
+        await this.insertFixture(trx, fixture);
+      }
+      for (const fixtureId of insertionOrder) {
+        const fixture = fixtures.find((f) => f.fixtureId === fixtureId);
+        await this.handleManyToManyRelations(trx, fixture, fixtures);
+      }
+      await trx.raw(`SET FOREIGN_KEY_CHECKS = 1`);
+    });
+    const records = [];
+    for await (const r of fixtures) {
+      const entity = EntityManager.get(r.entityId);
+      const record = await db(entity.table).where("id", r.id).first();
+      records.push({
+        entityId: r.entityId,
+        data: record
+      });
+    }
+    return records;
+  }
+  getInsertionOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const order = [];
+    const tempVisited = /* @__PURE__ */ new Set();
+    const visit = (fixtureId) => {
+      if (visited.has(fixtureId)) return;
+      if (tempVisited.has(fixtureId)) {
+        console.warn(`Circular dependency detected involving: ${fixtureId}`);
+        return;
+      }
+      tempVisited.add(fixtureId);
+      const node = this.dependencyGraph.get(fixtureId);
+      const entity = EntityManager.get(node.entityId);
+      for (const depId of node.dependencies) {
+        const depNode = this.dependencyGraph.get(depId);
+        const relationProp = entity.props.find(
+          (prop) => isRelationProp(prop) && (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) && prop.with === depNode.entityId
+        );
+        if (relationProp && !relationProp.nullable) {
+          visit(depId);
+        }
+      }
+      tempVisited.delete(fixtureId);
+      visited.add(fixtureId);
+      order.push(fixtureId);
+    };
+    for (const fixtureId of this.dependencyGraph.keys()) {
+      visit(fixtureId);
+    }
+    for (const fixtureId of this.dependencyGraph.keys()) {
+      if (!visited.has(fixtureId)) {
+        order.push(fixtureId);
+      }
+    }
+    return order;
+  }
+  prepareInsertData(fixture) {
+    const insertData = {};
+    for (const [propName, column] of Object.entries(fixture.columns)) {
+      if (isVirtualProp(column.prop)) {
+        continue;
+      }
+      const prop = column.prop;
+      if (!isRelationProp(prop)) {
+        if (prop.type === "json") {
+          insertData[propName] = JSON.stringify(column.value);
+        } else {
+          insertData[propName] = column.value;
+        }
+      } else if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+        insertData[`${propName}_id`] = column.value;
+      }
+    }
+    return insertData;
+  }
+  buildDependencyGraph(fixtures) {
+    this.dependencyGraph.clear();
+    for (const fixture of fixtures) {
+      this.dependencyGraph.set(fixture.fixtureId, {
+        fixtureId: fixture.fixtureId,
+        entityId: fixture.entityId,
+        dependencies: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const fixture of fixtures) {
+      const node = this.dependencyGraph.get(fixture.fixtureId);
+      for (const [, column] of Object.entries(fixture.columns)) {
+        const prop = column.prop;
+        if (isRelationProp(prop)) {
+          if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+            const relatedFixtureId = `${prop.with}#${column.value}`;
+            if (this.dependencyGraph.has(relatedFixtureId)) {
+              node.dependencies.add(relatedFixtureId);
+            }
+          } else if (isManyToManyRelationProp(prop)) {
+            const relatedIds = column.value;
+            for (const relatedId of relatedIds) {
+              const relatedFixtureId = `${prop.with}#${relatedId}`;
+              if (this.dependencyGraph.has(relatedFixtureId)) {
+                node.dependencies.add(relatedFixtureId);
+                this.dependencyGraph.get(relatedFixtureId).dependencies.add(fixture.fixtureId);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  async insertFixture(db, fixture) {
+    const insertData = this.prepareInsertData(fixture);
+    const entity = EntityManager.get(fixture.entityId);
+    try {
+      const found = await db(entity.table).where("id", fixture.id).first();
+      if (found && !fixture.override) {
+        return {
+          entityId: fixture.entityId,
+          id: found.id
+        };
+      }
+      const q = db.insert(insertData).into(entity.table);
+      await q.onDuplicateUpdate.apply(q, Object.keys(insertData));
+      return {
+        entityId: fixture.entityId,
+        id: fixture.id
+      };
+    } catch (err) {
+      console.log(err);
+      throw err;
+    }
+  }
+  async handleManyToManyRelations(db, fixture, fixtures) {
+    for (const [, column] of Object.entries(fixture.columns)) {
+      const prop = column.prop;
+      if (isManyToManyRelationProp(prop)) {
+        const joinTable = prop.joinTable;
+        const relatedIds = column.value;
+        for (const relatedId of relatedIds) {
+          if (!fixtures.find((f) => f.fixtureId === `${prop.with}#${relatedId}`)) {
+            continue;
+          }
+          const entity = EntityManager.get(fixture.entityId);
+          const relatedEntity = EntityManager.get(prop.with);
+          if (!entity || !relatedEntity) {
+            throw new Error(
+              `Entity not found: ${fixture.entityId}, ${prop.with}`
+            );
+          }
+          const [found] = await db(joinTable).where({
+            [`${_inflection2.default.singularize(entity.table)}_id`]: fixture.id,
+            [`${_inflection2.default.singularize(relatedEntity.table)}_id`]: relatedId
+          }).limit(1);
+          if (found) {
+            continue;
+          }
+          const newIds = await db(joinTable).insert({
+            [`${_inflection2.default.singularize(entity.table)}_id`]: fixture.id,
+            [`${_inflection2.default.singularize(relatedEntity.table)}_id`]: relatedId
+          });
+          console.log(
+            _chalk2.default.green(
+              `Inserted into ${joinTable}: ${entity.table}(${fixture.id}) - ${relatedEntity.table}(${relatedId}) ID: ${newIds}`
+            )
+          );
+        }
+      }
+    }
+  }
+  async addFixtureLoader(code) {
+    const path8 = Sonamu.apiRootPath + "/src/testing/fixture.ts";
+    let content = _fs.readFileSync.call(void 0, path8).toString();
+    const fixtureLoaderStart = content.indexOf("const fixtureLoader = {");
+    const fixtureLoaderEnd = content.indexOf("};", fixtureLoaderStart);
+    if (fixtureLoaderStart !== -1 && fixtureLoaderEnd !== -1) {
+      const newContent = content.slice(0, fixtureLoaderEnd) + "  " + code + "\n" + content.slice(fixtureLoaderEnd);
+      _fs.writeFileSync.call(void 0, path8, newContent);
+    } else {
+      throw new Error("Failed to find fixtureLoader in fixture.ts");
+    }
+  }
 };
 var FixtureManager = new FixtureManagerClass();
 
@@ -7443,4 +7758,4 @@ var FixtureManager = new FixtureManagerClass();
 
 
 exports.SQLDateTimeString = SQLDateTimeString; exports.zArrayable = zArrayable; exports.isIntegerProp = isIntegerProp; exports.isBigIntegerProp = isBigIntegerProp; exports.isTextProp = isTextProp; exports.isStringProp = isStringProp; exports.isEnumProp = isEnumProp; exports.isFloatProp = isFloatProp; exports.isDoubleProp = isDoubleProp; exports.isDecimalProp = isDecimalProp; exports.isBooleanProp = isBooleanProp; exports.isDateProp = isDateProp; exports.isDateTimeProp = isDateTimeProp; exports.isTimeProp = isTimeProp; exports.isTimestampProp = isTimestampProp; exports.isJsonProp = isJsonProp; exports.isUuidProp = isUuidProp; exports.isVirtualProp = isVirtualProp; exports.isRelationProp = isRelationProp; exports.isOneToOneRelationProp = isOneToOneRelationProp; exports.isBelongsToOneRelationProp = isBelongsToOneRelationProp; exports.isHasManyRelationProp = isHasManyRelationProp; exports.isManyToManyRelationProp = isManyToManyRelationProp; exports.isCustomJoinClause = isCustomJoinClause; exports.SonamuQueryMode = SonamuQueryMode; exports.isKnexError = isKnexError; exports.ApiParamType = ApiParamType; exports.RenderingNode = RenderingNode; exports.TemplateOptions = TemplateOptions; exports.TemplateKey = TemplateKey; exports.GenerateOptions = GenerateOptions; exports.PathAndCode = PathAndCode; exports.getZodObjectFromApi = getZodObjectFromApi; exports.getZodObjectFromApiParams = getZodObjectFromApiParams; exports.getZodTypeFromApiParamType = getZodTypeFromApiParamType; exports.propNodeToZodTypeDef = propNodeToZodTypeDef; exports.getTextTypeLength = getTextTypeLength; exports.propToZodTypeDef = propToZodTypeDef; exports.zodTypeToZodCode = zodTypeToZodCode; exports.apiParamToTsCode = apiParamToTsCode; exports.apiParamTypeToTsType = apiParamTypeToTsType; exports.unwrapPromiseOnce = unwrapPromiseOnce; exports.serializeZodType = serializeZodType; exports.zodTypeToTsTypeDef = zodTypeToTsTypeDef; exports.registeredApis = registeredApis; exports.api = api; exports.SoException = SoException; exports.isSoException = isSoException; exports.BadRequestException = BadRequestException; exports.UnauthorizedException = UnauthorizedException; exports.NotFoundException = NotFoundException; exports.ServiceUnavailableException = ServiceUnavailableException; exports.InternalServerErrorException = InternalServerErrorException; exports.AlreadyProcessedException = AlreadyProcessedException; exports.DuplicateRowException = DuplicateRowException; exports.TargetNotFoundException = TargetNotFoundException; exports.globAsync = globAsync; exports.importMultiple = importMultiple; exports.findAppRootPath = findAppRootPath; exports.findApiRootPath = findApiRootPath; exports.nonNullable = nonNullable; exports.Entity = Entity; exports.EntityManager = EntityManager; exports.Syncer = Syncer; exports.isLocal = isLocal; exports.isRemote = isRemote; exports.isInDocker = isInDocker; exports.isDaemonServer = isDaemonServer; exports.isDevelopment = isDevelopment; exports.isStaging = isStaging; exports.isProduction = isProduction; exports.isTest = isTest; exports.DB = DB; exports.isRefField = isRefField; exports.UpsertBuilder = UpsertBuilder; exports.BaseModelClass = BaseModelClass; exports.BaseModel = BaseModel; exports.Sonamu = Sonamu; exports.Migrator = Migrator; exports.FixtureManagerClass = FixtureManagerClass; exports.FixtureManager = FixtureManager;
-//# sourceMappingURL=chunk-5VT5JTY4.js.map
+//# sourceMappingURL=chunk-76VBQWGE.js.map