Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +Very seldom do users need to create a new collection with the API, but in the rare instances where this is necessary, +there are a couple of differences that should be noted.
+There is no need to create your own collection data class like with the record service, we helpfully provide one with +all the features need to create a collection.
+In this example we create the collection used in the usage example using +Pocketbase Kotlin.
+val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login {
+ token = client.admins.authWithPassword("email","password").token
+}
+
+//Simply use the collection object and fill out the fields as needed
+val collection = Collection(
+ name = "people",
+ type = Collection.CollectionType.BASE,
+ schema = listOf(
+ SchemaField(
+ name = "name",
+ type = SchemaField.SchemaFieldType.TEXT,
+ required = true,
+ ),
+ SchemaField(
+ name = "age",
+ type = SchemaField.SchemaFieldType.NUMBER,
+ required = true,
+ options = SchemaField.SchemaOptions(
+ //Some options such as min and max can different types
+ //to fix this issue we serialise them as JsonPrimitives
+ min = 0.toJsonPrimitive(),
+ max = 150.toJsonPrimitive()
+ )
+ ),
+ SchemaField(
+ name = "pet",
+ type = SchemaField.SchemaFieldType.SELECT,
+ required = false,
+ options = SchemaField.SchemaOptions(
+ values = listOf("Dog","Cat","Bird")
+ )
+ )
+ )
+)
+//The generic '<Collection>' encodes our collection to JSON based on the Collection class
+client.collections.create<Collection>(Json.encodeToString(collection))
+Due to the fact that Pocketbase Kotlin is multiplatform, file uploads do not use the Java File class.
+There is a special utility class called FileUpload designed specifically for this task.
+Although there are some caveats to using file uploads, as the way we handle multipart form data prevents using
+serialised records. Meaning that we must use a key value map of Json elements.
val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login {
+ token = client.users.authWithPassword("email","password").token
+}
+
+///Make sure that the field for your file is a string
+//If you have multiple file uploads in your schema make it a list of strings
+@Serializable
+data class FileUploadRecord(val imageFile: String, val imageDescription: String) : Record()
+
+client.records.create<FileUploadRecord>(
+ "fileUploadCollection",
+ //A workaround to the limitations on JSON with multipart form data
+ mapOf(
+ "imageDescription" to "A house".toJsonPrimitive()
+ ),
+ //Here is where the files are uploaded from
+ //Swap ByteArray(0) with the file's content as a ByteArray
+ listOf(
+ FileUpload("imageFile", ByteArray(0), "house.png")
+ )
+)
+val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login {
+ token = client.users.authWithPassword("email", "password").token
+}
+
+//For this example imagine we have two collections. One that contains users...
+@Serializable
+data class PersonRecord(val name: String) : User()
+
+//And one that contains their pets
+//Each Pet has a name (text), owner (relation), and each Person has a name (text)
+@Serializable
+data class PetRecord(val owner: String,val name: String) : ExpandRecord<PersonRecord>()
+//This example gets a list of pets, selects the first one and gets its owner
+
+val records = client.records.getList<PetRecord>("pets_collection",1,3,
+//This tells Pocketbase to expand the relation field of owner
+ expandRelations = ExpandRelations("owner"))
+
+//This returns the expanded record with the field name of owner
+val owner: PersonRecord? = records.items[0].expand?.get("owner")
+This section is dedicated to informing users of the small quirks and irregularities between Pocketbase Kotlin and +the official Pocketbase web API.
+There is a document for each service and their irregularities and quirks.
+ +Pocketbase Kotlin offers support for Pocketbase 0.20 and above. +and above. +Support for new Pocketbase releases will be added as soon as possible.
+Currently, the following platforms are supported,
+| Supported Platforms |
|---|
| JVM |
| Linux (x64) |
| Windows (x64) |
| Mac OS (x64) (arm x64) |
| IOS (arm x64) (x64) (sim arm x64) |
Want a platform supported? Open an issue, and we will try our +best to add it.
+Using this library requires the +KotlinX Serialization plugin
+To use Pocketbase Kotlin just add the following into your buildscript:
+repositories {
+ mavenCentral()
+}
+
+dependencies {
+ implementation("io.github.agrevster:pocketbase-kotlin:2.6.0")
+}
+Pocketbase Kotlin offers support for Pocketbase 0.20 and above. +and above. +Support for new Pocketbase releases will be added as soon as possible.
+Currently, the following platforms are supported,
+| Supported Platforms |
|---|
| JVM |
| Linux (x64) |
| Windows (x64) |
| Mac OS (x64) (arm x64) |
| IOS (arm x64) (x64) (sim arm x64) |
Want a platform supported? Open an issue, and we will try our +best to add it.
+Using this library requires the +KotlinX Serialization plugin
+To use Pocketbase Kotlin just add the following into your buildscript:
+repositories {
+ mavenCentral()
+}
+
+dependencies {
+ implementation("io.github.agrevster:pocketbase-kotlin:2.6.0")
+}
+Pocketbase Kotlin offers support for Pocketbase 0.20 and above. +and above. +Support for new Pocketbase releases will be added as soon as possible.
+Currently, the following platforms are supported,
+| Supported Platforms |
|---|
| JVM |
| Linux (x64) |
| Windows (x64) |
| Mac OS (x64) (arm x64) |
| IOS (arm x64) (x64) (sim arm x64) |
Want a platform supported? Open an issue, and we will try our +best to add it.
+Using this library requires the +KotlinX Serialization plugin
+To use Pocketbase Kotlin just add the following into your buildscript:
+repositories {
+ mavenCentral()
+}
+
+dependencies {
+ implementation("io.github.agrevster:pocketbase-kotlin:2.6.0")
+}
+The PocketbaseClient is the class used to access the Pocketbase API.
//Creates a new pocketbase client with the given url
+// The client is used to access everything in the Pocketbase API
+val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+//Logging in
+client.login { token = "TOKEN FROM AN AUTH METHOD" }
+Logging the client in allows it to call methods that require Pocketbase authentication. +The current login token is saved and applied to every api request.
+If you want to log the client out simply use client.logout()
val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+var loginToken: String
+//Using the admin auth service to log in
+loginToken = client.admins.authWithPassword("email", "password").token
+
+//Using the collection auth service to log in
+// This authenticates a user rather than an admin
+//The user auth service is the same as collection auth, but it uses the "users" collection
+loginToken = client.records.authWithPassword<User>("collectionName", "email", "password").token
+loginToken = client.records.authWithUsername<User>("collectionName", "username", "password").token
+//You can also use oauth2
+loginToken =
+ client.records.authWithOauth2<User>("collectionName", "provider", "code", "codeVerifier", "redirectUrl").token
+
+client.login { token = loginToken }
+ val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login { token = client.users.authWithPassword("email","password").token }
+
+//We are using this to hold records created in the collection "people".
+//Each record has a name (required), age (required number) and a pet optional.
+//If a value is optional in the collection's schema make sure the kotlin type is nullable and defaults to null.
+//All record classes mst be @Serializable and extend Record.
+@Serializable
+data class PersonRecord(val name: String, val age: Int,val pet: String? = null): Record()
+
+val recordToCreate = PersonRecord("Tim",4)
+//Generics are used to define the return type of api calls, just make sure that the record class you created matches the collection's schema.
+val response = client.records.create<PersonRecord>("people",Json.encodeToString(recordToCreate))
+//You can now use the data from the response.
+val collectionId = response.collectionId
+All done! Now that you have a Pocketbase client set up and know how to log in, the rest is easy! +Simply follow the Pocketbase Web API Docs and our internal KDocs to find your +way around the Pocketbase API. +There are a few exceptions for which features could not be made to match the other SDKs, for a guide on them go to +our caveats page
+This section is dedicated to informing users of the small quirks and irregularities between Pocketbase Kotlin and +the official Pocketbase web API.
+There is a document for each service and their irregularities and quirks.
+Very seldom do users need to create a new collection with the API, but in the rare instances where this is necessary, +there are a couple of differences that should be noted.
+There is no need to create your own collection data class like with the record service, we helpfully provide one with +all the features need to create a collection.
+In this example we create the collection used in the usage example using +Pocketbase Kotlin.
+val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login {
+ token = client.admins.authWithPassword("email","password").token
+}
+
+//Simply use the collection object and fill out the fields as needed
+val collection = Collection(
+ name = "people",
+ type = Collection.CollectionType.BASE,
+ schema = listOf(
+ SchemaField(
+ name = "name",
+ type = SchemaField.SchemaFieldType.TEXT,
+ required = true,
+ ),
+ SchemaField(
+ name = "age",
+ type = SchemaField.SchemaFieldType.NUMBER,
+ required = true,
+ options = SchemaField.SchemaOptions(
+ //Some options such as min and max can different types
+ //to fix this issue we serialise them as JsonPrimitives
+ min = 0.toJsonPrimitive(),
+ max = 150.toJsonPrimitive()
+ )
+ ),
+ SchemaField(
+ name = "pet",
+ type = SchemaField.SchemaFieldType.SELECT,
+ required = false,
+ options = SchemaField.SchemaOptions(
+ values = listOf("Dog","Cat","Bird")
+ )
+ )
+ )
+)
+//The generic '<Collection>' encodes our collection to JSON based on the Collection class
+client.collections.create<Collection>(Json.encodeToString(collection))
+Due to the fact that Pocketbase Kotlin is multiplatform, file uploads do not use the Java File class.
+There is a special utility class called FileUpload designed specifically for this task.
+Although there are some caveats to using file uploads, as the way we handle multipart form data prevents using
+serialised records. Meaning that we must use a key value map of Json elements.
val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login {
+ token = client.users.authWithPassword("email","password").token
+}
+
+///Make sure that the field for your file is a string
+//If you have multiple file uploads in your schema make it a list of strings
+@Serializable
+data class FileUploadRecord(val imageFile: String, val imageDescription: String) : Record()
+
+client.records.create<FileUploadRecord>(
+ "fileUploadCollection",
+ //A workaround to the limitations on JSON with multipart form data
+ mapOf(
+ "imageDescription" to "A house".toJsonPrimitive()
+ ),
+ //Here is where the files are uploaded from
+ //Swap ByteArray(0) with the file's content as a ByteArray
+ listOf(
+ FileUpload("imageFile", ByteArray(0), "house.png")
+ )
+)
+val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login {
+ token = client.users.authWithPassword("email", "password").token
+}
+
+//For this example imagine we have two collections. One that contains users...
+@Serializable
+data class PersonRecord(val name: String) : User()
+
+//And one that contains their pets
+//Each Pet has a name (text), owner (relation), and each Person has a name (text)
+@Serializable
+data class PetRecord(val owner: String,val name: String) : ExpandRecord<PersonRecord>()
+//This example gets a list of pets, selects the first one and gets its owner
+
+val records = client.records.getList<PetRecord>("pets_collection",1,3,
+//This tells Pocketbase to expand the relation field of owner
+ expandRelations = ExpandRelations("owner"))
+
+//This returns the expanded record with the field name of owner
+val owner: PersonRecord? = records.items[0].expand?.get("owner")
+The PocketbaseClient is the class used to access the Pocketbase API.
//Creates a new pocketbase client with the given url
+// The client is used to access everything in the Pocketbase API
+val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+//Logging in
+client.login { token = "TOKEN FROM AN AUTH METHOD" }
+Logging the client in allows it to call methods that require Pocketbase authentication. +The current login token is saved and applied to every api request.
+If you want to log the client out simply use client.logout()
val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+var loginToken: String
+//Using the admin auth service to log in
+loginToken = client.admins.authWithPassword("email", "password").token
+
+//Using the collection auth service to log in
+// This authenticates a user rather than an admin
+//The user auth service is the same as collection auth, but it uses the "users" collection
+loginToken = client.records.authWithPassword<User>("collectionName", "email", "password").token
+loginToken = client.records.authWithUsername<User>("collectionName", "username", "password").token
+//You can also use oauth2
+loginToken =
+ client.records.authWithOauth2<User>("collectionName", "provider", "code", "codeVerifier", "redirectUrl").token
+
+client.login { token = loginToken }
+ val client = PocketbaseClient({
+ protocol = URLProtocol.HTTP
+ host = "localhost"
+ port = 8090
+})
+
+client.login { token = client.users.authWithPassword("email","password").token }
+
+//We are using this to hold records created in the collection "people".
+//Each record has a name (required), age (required number) and a pet optional.
+//If a value is optional in the collection's schema make sure the kotlin type is nullable and defaults to null.
+//All record classes mst be @Serializable and extend Record.
+@Serializable
+data class PersonRecord(val name: String, val age: Int,val pet: String? = null): Record()
+
+val recordToCreate = PersonRecord("Tim",4)
+//Generics are used to define the return type of api calls, just make sure that the record class you created matches the collection's schema.
+val response = client.records.create<PersonRecord>("people",Json.encodeToString(recordToCreate))
+//You can now use the data from the response.
+val collectionId = response.collectionId
+All done! Now that you have a Pocketbase client set up and know how to log in, the rest is easy! +Simply follow the Pocketbase Web API Docs and our internal KDocs to find your +way around the Pocketbase API. +There are a few exceptions for which features could not be made to match the other SDKs, for a guide on them go to +our caveats page
+ +