@peerbit/indexer-sqlite3 2.1.0 → 2.1.1-2ed894b

package/dist/index.min.js

@@ -20355,6 +20355,58 @@ 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;
+    }
+    if (fieldType instanceof FixedArrayKind && fieldType.elementType === "u8") {
+      fieldType = Uint8Array;
+    } else {
+      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) {
@@ -20438,10 +20490,20 @@ 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,
@@ -20457,17 +20519,17 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
       {
         name: PARENT_TABLE_ID,
         key: PARENT_TABLE_ID,
-        definition: `${PARENT_TABLE_ID} ${parentPrimaryFieldType}`,
-        type: parentPrimaryFieldType,
-        from: parentPrimaryField?.from,
-        unwrappedType: parentPrimaryField?.unwrappedType,
+        definition: `${PARENT_TABLE_ID} ${parentPrimaryFieldInfo.type}`,
+        type: parentPrimaryFieldInfo.type,
+        from: parentPrimaryFieldInfo.from,
+        unwrappedType: parentPrimaryFieldInfo.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}(${parentPrimaryFieldName}) ON DELETE CASCADE`
+      definition: `CONSTRAINT ${PARENT_TABLE_ID}_fk FOREIGN KEY(${PARENT_TABLE_ID}) REFERENCES ${tableName}(${parentPrimaryFieldInfo.name}) ON DELETE CASCADE`
     });
   };
   const handleNestedType = (key, field2) => {
@@ -20546,28 +20608,17 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
       }
     }
   };
-  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 handleSimpleField = (field2, type, isOptional2) => {
+    const sqlField = createScalarSQLField(path, field2, type, primary, isOptional2);
+    foundPrimary = foundPrimary || sqlField.isPrimary;
+    sqlFields.push(sqlField);
   };
   const handleField = (key, field2, type, isOptional2) => {
     if (type instanceof FixedArrayKind && type.elementType === "u8") {
       type = Uint8Array;
     }
     if (typeof type === "string" || type === Uint8Array) {
-      handleSimpleField(key, field2, type, true);
+      handleSimpleField(field2, type, true);
     } else if (typeof type === "function" && clazzCanBeInlined(type)) {
       const subPath = [...path, key];
       const subtables = getSQLTable(type, subPath, false, true, addJoinFields, isOptional2);