@peerbit/indexer-sqlite3 2.1.0-369b236 → 2.1.0

package/dist/index.min.js

@@ -20355,54 +20355,6 @@ var toSQLType = (type, isOptional = false) => {
   }
   return isOptional ? ret : ret + " NOT NULL";
 };
-var createScalarSQLField = (path, field2, type, primary, isOptional) => {
-  const name = getInlineTableFieldName(path.slice(1), field2.key);
-  const isPrimary = primary !== false && name === primary;
-  const sqlType = toSQLType(type, isOptional);
-  return {
-    name,
-    key: field2.key,
-    definition: `${escapeColumnName(name)} ${sqlType} ${isPrimary ? "PRIMARY KEY" : ""}`,
-    type: sqlType,
-    isPrimary,
-    from: field2,
-    unwrappedType: unwrapNestedType(field2.type),
-    path: [...path.slice(1), field2.key]
-  };
-};
-var resolvePrimaryFieldInfoFromSchema = (ctor, path, primary) => {
-  const schema = getSchema(ctor);
-  if (!schema) {
-    return void 0;
-  }
-  for (const field2 of schema.fields) {
-    let fieldType = field2.type;
-    if (fieldType instanceof OptionKind) {
-      fieldType = fieldType.elementType;
-    }
-    fieldType = unwrapNestedType(fieldType);
-    if (fieldType instanceof VecKind) {
-      continue;
-    }
-    if (typeof fieldType === "string" || isUint8ArrayType(fieldType)) {
-      const sqlField = createScalarSQLField(path, field2, fieldType, primary, true);
-      if (sqlField.isPrimary) {
-        return {
-          name: sqlField.name,
-          type: sqlField.type,
-          from: sqlField.from,
-          unwrappedType: sqlField.unwrappedType
-        };
-      }
-    } else if (typeof fieldType === "function" && clazzCanBeInlined(fieldType)) {
-      const nested = resolvePrimaryFieldInfoFromSchema(fieldType, [...path, field2.key], primary);
-      if (nested) {
-        return nested;
-      }
-    }
-  }
-  return void 0;
-};
 var getSQLTable = (ctor, path, primary, inline, addJoinField, fromOptionalField = false) => {
   let clazzes = getDependencies(ctor, 0);
   if (!clazzes || clazzes.length === 0) {
@@ -20486,20 +20438,10 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
   const sqlFields = [];
   const sqlConstraints = [];
   let foundPrimary = false;
-  const parentPrimaryFieldInfo = primary === false || primary === CHILD_TABLE_ID ? {
-    name: CHILD_TABLE_ID,
-    type: "INTEGER",
-    from: void 0,
-    unwrappedType: void 0
-  } : resolvePrimaryFieldInfoFromSchema(ctor, path, primary) || {
-    // Fallback: nested tables use synthetic integer ids, and we allow that
-    // primary to be unresolved here.
-    name: primary,
-    type: "INTEGER",
-    from: void 0,
-    unwrappedType: void 0
-  };
   const addJoinFields = primary === false ? addJoinFieldFromParent : (fields2, contstraints) => {
+    const parentPrimaryField = primary != null ? sqlFields.find((field2) => field2.name === primary) : void 0;
+    const parentPrimaryFieldName = parentPrimaryField?.name || CHILD_TABLE_ID;
+    const parentPrimaryFieldType = parentPrimaryField ? parentPrimaryField.type : "INTEGER";
     fields2.unshift(
       {
         name: CHILD_TABLE_ID,
@@ -20515,17 +20457,17 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
       {
         name: PARENT_TABLE_ID,
         key: PARENT_TABLE_ID,
-        definition: `${PARENT_TABLE_ID} ${parentPrimaryFieldInfo.type}`,
-        type: parentPrimaryFieldInfo.type,
-        from: parentPrimaryFieldInfo.from,
-        unwrappedType: parentPrimaryFieldInfo.unwrappedType,
+        definition: `${PARENT_TABLE_ID} ${parentPrimaryFieldType}`,
+        type: parentPrimaryFieldType,
+        from: parentPrimaryField?.from,
+        unwrappedType: parentPrimaryField?.unwrappedType,
         isPrimary: false,
         path: [PARENT_TABLE_ID]
       }
     );
     contstraints.push({
       name: `${PARENT_TABLE_ID}_fk`,
-      definition: `CONSTRAINT ${PARENT_TABLE_ID}_fk FOREIGN KEY(${PARENT_TABLE_ID}) REFERENCES ${tableName}(${parentPrimaryFieldInfo.name}) ON DELETE CASCADE`
+      definition: `CONSTRAINT ${PARENT_TABLE_ID}_fk FOREIGN KEY(${PARENT_TABLE_ID}) REFERENCES ${tableName}(${parentPrimaryFieldName}) ON DELETE CASCADE`
     });
   };
   const handleNestedType = (key, field2) => {
@@ -20604,17 +20546,28 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
       }
     }
   };
-  const handleSimpleField = (field2, type, isOptional2) => {
-    const sqlField = createScalarSQLField(path, field2, type, primary, isOptional2);
-    foundPrimary = foundPrimary || sqlField.isPrimary;
-    sqlFields.push(sqlField);
+  const handleSimpleField = (key, field2, type, isOptional2) => {
+    let keyString = getInlineTableFieldName(path.slice(1), key);
+    const isPrimary = primary != null && keyString === primary;
+    foundPrimary = foundPrimary || isPrimary;
+    const fieldType = toSQLType(type, isOptional2);
+    sqlFields.push({
+      name: keyString,
+      key,
+      definition: `${escapeColumnName(keyString)} ${fieldType} ${isPrimary ? "PRIMARY KEY" : ""}`,
+      type: fieldType,
+      isPrimary,
+      from: field2,
+      unwrappedType: unwrapNestedType(field2.type),
+      path: [...path.slice(1), key]
+    });
   };
   const handleField = (key, field2, type, isOptional2) => {
     if (type instanceof FixedArrayKind && type.elementType === "u8") {
       type = Uint8Array;
     }
     if (typeof type === "string" || type === Uint8Array) {
-      handleSimpleField(field2, type, true);
+      handleSimpleField(key, field2, type, true);
     } else if (typeof type === "function" && clazzCanBeInlined(type)) {
       const subPath = [...path, key];
       const subtables = getSQLTable(type, subPath, false, true, addJoinFields, isOptional2);