Programmatically create entity/table using CoreData and insert values into that entity in Swift 3 for iOS

Some of the steps you describe are simply not possible with Core Data. Or at least, not without making things extremely complex and difficult for you. Asking for complete working code is not reasonable because you have an extremely unusual and complex set of requirements for Core Data.

It's true that the NSManagedModel and all of the entities are mutable and can be changed in code. Except, all of these changes must be made before you use that model to load any data. You cannot make changes after you call loadPersistentStores(_:) (if you're using NSPersistentContainer) or addPersistentStore(ofType:configurationName:at:options:) (if you're not using NSPersistentContainer). Doing so is a run-time error that will crash your app.

Because of this, the idea of providing a user interface to dynamically create and delete Core Data entities is not really an option. You can create and delete instances of entities but not the entity descriptions.

If you're willing to do a lot of hard work, you might be able to get something close. The closest you could get with Core Data would be to create an entirely new managed object model any time you need a change. Then copy all of your data to a new persistent store file using this model (including whatever custom code you need to handle non-lightweight migration). Then delete the old model and persistent store file and all references to all objects that you previously fetched with them.

This will be very difficult to get right and may have unforeseen difficulties that I haven't thought of. I would strongly urge not attempting to do this with Core Data, because it was not designed to be used in this way.

It can be done quit simply with the following code:

import Foundation
import CoreData

class CoreData {

static let shared = CoreData()

let dataBase = NSManagedObjectModel()
   
let dbTable:NSEntityDescription = {
    let tableEntity = NSEntityDescription()
    tableEntity.name = "NEntity"
    tableEntity.managedObjectClassName = "NEntity"
    return tableEntity
}()

// The attributes each item in the table will have. e.g. id, name, password, date
let dbTableAttribute:NSAttributeDescription =  {
    let tblAttr = NSAttributeDescription()
    tblAttr.name = "id"
    tblAttr.attributeType = .integer64AttributeType
    tblAttr.isOptional = true
    return tblAttr
}()

lazy var persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "APICall", managedObjectModel: dataBase)
    container.loadPersistentStores(completionHandler: { (storeDescription, error) in
        if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
    return container
}()

private init(){
    dataBase.entities.append(dbTable)
    dbTable.properties.append(dbTableAttribute)
}

func saveContext () {
    let context = persistentContainer.viewContext
    if context.hasChanges {
        do {
            try context.save()
        } catch {
            let nserror = error as NSError
            fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }
}
}




// MARK: - Defining the class for the table, you can put this in a seperate file if you want but for ease of copying I put them together

@objc(NEntity)
public class NEntity: NSManagedObject {

// Variables must be NSManaged to be saved to the database
@NSManaged var id:Int64

// Call this function to save a new item to the table
static func addEntity(_ id:Int) {
    
    let entityName = NSStringFromClass(self)
    
    let moc = CoreData.shared.persistentContainer.viewContext
    guard let entity =  NSEntityDescription.insertNewObject(forEntityName:entityName, into: moc)
            as? NEntity
    else { print("Could not find entity: \(entityName) in database: \(CoreData.shared.persistentContainer.name)"); return }
    
    entity.id = Int64(id)

    // Update database
    CoreData.shared.saveContext()
}

//Call this function to search the database for items matching the id, see removeEntityWithAttribute() for example
func fetchEntityByAttribute(id:Int, completion:@escaping ([NEntity]?) -> ()){
    let moc = CoreData.shared.persistentContainer.viewContext

    let fetchRequest = NEntity.fetchRequest()
    
    fetchRequest.predicate = NSPredicate(format: "id == %d", id)
    moc.perform {

        guard let  result = try? fetchRequest.execute() else {
            return
        }
        if result.count > 0 {
            completion((result as! [NEntity]))
        }else {
            completion(nil)
        }
    }
    
}

//Call this function to delete entities from the database with the matching id
func removeEntityWithAttribute(id:Int) {
    
    let moc = CoreData.shared.persistentContainer.viewContext

    fetchEntityByAttribute(id:id) { matchedEntities in
        
        if let matchingEntities = matchedEntities {
            matchingEntities.forEach(){
                moc.delete($0)
                CoreData.shared.saveContext()
            }
        }
        
    }
}
}

Just call NEntity.addEntity(5) anywhere in your code to save an item in the database with an id of 5. Be sure to give them unique ids so you can edit and delete them.

Sources:

https://tigi44.github.io/ios/iOS,-Swift-Core-Data-Model-in-a-Swift-Package/

https://dmytro-anokhin.medium.com/core-data-and-swift-package-manager-6ed9ff70921a