Examples

On this page you will find some more complex examples of using the Deta SDK.

Base

Put

import (
    "log"
    "time"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type User struct {
    // JSON struct tag "key" used to denote the key.
    Key      string   `json:"key"`
    Username string   `json:"username"`
    Active   bool     `json:"active"`
    Age      int      `json:"age"`
    Likes    []string `json:"likes"`
    // JSON struct tag "__expires" for expiration timestamp.
    // "omitempty" for omission of default 0 value.
    Expires  int64 `json:"__expires,omitempty"`
}

func main() {
    // Errors ignored for brevity.
    d, _ := deta.New(deta.WithProjectKey("project_key"))
    db, _ := base.New(d, "users")

    u := &User{
        Key:      "kasdlj1",
        Username: "jimmy",
        Active:   true,
        Age:      20,
        Likes:    []string{"ramen"},
    }
    key, err := db.Put(u)
    if err != nil {
        log.Fatal("failed to put item:", err)
    }
    log.Println("Successfully put item with key", key)

    // Can also use a map.
    um := map[string]interface{}{
        "key":      "kasdlj1",
        "username": "jimmy",
        "active":   true,
        "age":      20,
        "likes":    []string{"ramen"},
    }
    key, err = db.Put(um)
    if err != nil {
        log.Fatal("Failed to put item:", err)
    }
    log.Println("Successfully put item with key:", key)

    // Put with expiry date.
    u := &User{
        Key: "will_be_deleted",
        Username: "test_user",
        Expires: time.Date(2023, 1, 1, 0, 0, 0, 0, 0, time.UTC).Unix(),
    }
    key, err = db.Put(u)
    if err != nil {
        log.Fatal("failed to put item:", err)
    }
    log.Println("Successfully put item with key:", key)

    // Put map with expiry date.
    um = map[string]interface{}{
        "key": "will_be_deleted",
        "test": true,
        "__expires": time.Data(2023, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
    }
    key, err = db.Put(um)
    if err != nil {
        log.Fatal("failed to put item:", err)
    }
    log.Println("Successfully put item with key:", key)
}

const Deta = require('deta');

const deta = Deta(); //instantiate with Data Key or env DETA_PROJECT_KEY

const db = deta.Base("simple_db");

// Store objects.
// A key will be automatically generated.
await db.put({ name: "alex", age: 77 });
// We will use "one" as a key.
await db.put({ name: "alex", age: 77 }, "one");
// The key could also be included in the object itself.
await db.put({ name: "alex", age: 77, key: "one" });

// Store simple types.
await db.put("hello, worlds");
await db.put(7);
// "success" is the value and "smart_work" is the key.
await db.put("success", "smart_work");
await db.put(["a", "b", "c"], "my_abc");

// Put expiring items.
// Expire in 300 seconds.
await db.put({ name: "alex", age: 21 }, "alex21", { expireIn: 300 });
// Expire at date.
await db.put({ name: "max", age: 28 }, "max28", { expireAt: new Date("2023-01-01T00:00:00") });

from deta import Deta

deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY

db = deta.AsyncBase("simple_db")

# Store objects.
# A key will be automatically generated.
await db.put({"name": "alex", "age": 77})
# We will use "one" as a key.
await db.put({"name": "alex", "age": 77}, "one")
# The key could also be included in the object itself.
await db.put({"name": "alex", "age": 77, "key": "one"})

# Simple types.
await db.put("hello, worlds")
await db.put(7)
# "success" is the value and "smart_work" is the key.
await db.put("success", "smart_work")
await db.put(["a", "b", "c"], "my_abc")

# Expire in 300 seconds.
await db.put({"name": "alex", "age": 23}, "alex23", expire_in=300)
# Expire at date.
expire_at = datetime.fromisoformat("2023-01-01T00:00:00")
await db.put({"name": "max", "age": 28}, "max28", expire_at=expire_at)

# Close db session
await db.close()

from deta import Deta

deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY

db = deta.Base("simple_db")

# Store objects.
# A key will be automatically generated.
db.put({"name": "alex", "age": 77})
# We will use "one" as a key.
db.put({"name": "alex", "age": 77}, "one")
# The key could also be included in the object itself.
db.put({"name": "alex", "age": 77, "key": "one"})

# Simple types.
db.put("hello, worlds")
db.put(7)
# "success" is the value and "smart_work" is the key.
db.put("success", "smart_work")
db.put(["a", "b", "c"], "my_abc")

# Expire in 300 seconds.
db.put({"name": "alex", "age": 23}, "alex23", expire_in=300)
# Expire at date.
expire_at = datetime.fromisoformat("2023-01-01T00:00:00")
db.put({"name": "max", "age": 28}, "max28", expire_at=expire_at)

Get

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type User struct {
    Key      string   `json:"key"`
    Username string   `json:"username"`
    Active   bool     `json:"active"`
    Age      int      `json:"age"`
    Likes    []string `json:"likes"`
}

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    db, err := base.New(d, "users")
    if err != nil {
        fmt.Println("Failed to init new Base instance:", err)
    }

    // Declare a variable to store the result.
    var u User

    // Get an item.
    err = db.Get("kasdlj1", &u)
    if err != nil {
        fmt.Println("Failed to get item:", err)
    }
}

const item = await db.get('one'); // retrieving item with key "one"

If the record is found, the returned promise will resolve to an object, else null:

{
  name: 'alex', age: 77, key: 'one'
}

item = db.get("one") # retrieving item with key "one"

If the record is found, will return an object, else None:

{
  "name": "alex", "age": 77, "key": "one"
}

item = await db.get("one") # retrieving item with key "one"

# Close db session
await db.close()

If the record is found, will return an object, else None:

{
  "name": "alex", "age": 77, "key": "one"
}

Insert

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type User struct {
    Key      string   `json:"key"`
    Username string   `json:"username"`
    Active   bool     `json:"active"`
    Age      int      `json:"age"`
    Likes    []string `json:"likes"`
}

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    db, err := base.New(d, "users")
    if err != nil {
        fmt.Println("Failed to init new Base instance:", err)
    }

    u := &User{
        Key:      "kasdlj1",
        Username: "jimmy",
        Active:   true,
        Age:      20,
        Likes:    []string{"ramen"},
    }

    // Insert item into the Base.
    key, err := db.Insert(u)
    if err != nil {
        fmt.Println("Failed to insert item:", err)
        return
    }
    fmt.Println("Successfully inserted item with key:", key)
}

const Deta = require('deta');

const deta = Deta(); //instantiate with Data Key or env DETA_PROJECT_KEY

const db = deta.Base("simple_db");

// Will succeed, a key will be auto-generated.
const res1 = await db.insert("hello, world");

// Will succeed.
const res2 = await db.insert({ message: "hello, world" }, "greeting1");

// Will raise an error as key "greeting1" already exists.
const res3 = await db.insert({ message: "hello, there" }, "greeting1");

// Expire in 300 seconds.
await db.insert({ message: "will be deleted" }, "temp_key", { expireIn: 300 });

// Expire at date.
await db.insert({ message: "will be deleted" }, "temp_key_2", { expireAt: new Date("2023-01-01T00:00:00") });

from deta import Deta

deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY

db = deta.Base("simple_db")

# Will succeed, a key will be auto-generated.
db.insert("hello, world")

# Will succeed.
db.insert({"message": "hello, world"}, "greeting1")

# Will raise an error as key "greeting1" already exists.
db.insert({"message": "hello, there"}, "greeting1")

# Expire in 300 seconds.
db.insert({"message": "will be deleted"}, "temp_greeting", expire_in=300)

# Expire at date.
expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")
db.insert({"message": "will_be_deleted"}, "temp_greeting2", expire_at=expire_at)

from deta import Deta

deta = Deta("Data Key") #instantiate with a Data Key, or env DETA_PROJECT_KEY

db = deta.AsyncBase("simple_db")

# Will succeed, a key will be auto-generated.
await db.insert("hello, world")

# Will succeed.
await db.insert({"message": "hello, world"}, "greeting1")

# Will raise an error as key "greeting1" already exists.
await db.insert({"message": "hello, there"}, "greeting1")

# Expire in 300 seconds.
await db.insert({"message": "will be deleted"}, "temp_greeting", expire_in=300)

# Expire at date.
expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")
await db.insert({"message": "will_be_deleted"}, "temp_greeting2", expire_at=expire_at)

# Close db session
await db.close()

Put Many

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type User struct {
    Key      string   `json:"key"`
    Username string   `json:"username"`
    Active   bool     `json:"active"`
    Age      int      `json:"age"`
    Likes    []string `json:"likes"`
}

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    db, err := base.New(d, "users")
    if err != nil {
        fmt.Println("Failed to init new Base instance:", err)
    }

    // Define two users.
    u1 := &User{
        Key:      "kasdlj1",
        Username: "jimmy",
        Active:   true,
        Age:      20,
        Likes:    []string{"ramen"},
    }
    u2 := &User{
        Key:      "askdjf",
        Username: "joel",
        Active:   true,
        Age:      23,
        Likes:    []string{"coffee"},
    }
    users := []*User{u1, u2}

    // Put items into the Base.
    keys, err := db.PutMany(users)
    if err != nil {
        fmt.Println("Failed to put items:", err)
        return
    }
    fmt.Println("Successfully put items with keys:", keys)
}

await db.putMany([
  { name: "Beverly", hometown: "Copernicus City", key: "one" }, // Key provided.
  ["Namaskāra", "marhabaan", "hello", "yeoboseyo"], // Key auto-generated.
  "dude", // Key auto-generated.
]);

// Put many to expire in 300 seconds.
await db.putMany(
  [
    { key: "temp-1", name: "test-1" },
    { key: "temp-2", name: "test-2" },
  ],
  { expireIn: 300 },
);

// Put many with expiry date.
await db.putMany(
  [
    { key: "temp-1", name: "test-1" },
    { key: "temp-2", name: "test-2" },
  ],
  { expireAt: new Date("2023-01-01T00:00:00") },
);

Example output:

{
  "processed": {
    "items": [
      {
        "hometown": "Copernicus City",
        "key": "one",
        "name": "Beverly"
      },
      {
        "key": "5feqybn7lb05",
        "value": ["Namaskāra", "hello", "marhabaan", "yeoboseyo"]
      },
      {
        "key": "jyesxxlrezo0",
        "value": "dude"
      }
    ]
  }
}

db.put_many([
    {"name": "Beverly", "hometown": "Copernicus City", "key": "one"},  # Key provided.
    ["Namaskāra", "marhabaan", "hello", "yeoboseyo"],  # Key auto-generated.
    "dude",  # Key auto-generated.
])

# Put many to expire in 300 seconds.
db.put_many(
    [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}],
    expire_in=300,
)

# Put many with expiry date.
expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")
db.put_many(
    [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}],
    expire_at=expire_at,
)

Output example:

{
  "processed": {
    "items": [
      {
        "hometown": "Copernicus City",
        "key": "one",
        "name": "Beverly"
      },
      {
        "key": "5feqybn7lb05",
        "value": ["Namaskāra", "hello", "marhabaan", "yeoboseyo"]
      },
      {
        "key": "jyesxxlrezo0",
        "value": "dude"
      }
    ]
  }
}

await db.put_many([
    {"name": "Beverly", "hometown": "Copernicus City", "key": "one"},  # Key provided.
    ["Namaskāra", "marhabaan", "hello", "yeoboseyo"],  # Key auto-generated.
    "dude",  # Key auto-generated.
])

# Put many to expire in 300 seconds.
await db.put_many(
    [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}],
    expire_in=300,
)

# Put many with expiry date.
expire_at = datetime.datetime.fromisoformat("2023-01-01T00:00:00")
await db.put_many(
    [{"key": "tmp-1", "value": "test-1"}, {"key": "tmp-2", "value": "test-2"}],
    expire_at=expire_at,
)

# Close db session
await db.close()

Output example:

{
  "processed": {
    "items": [
      {
        "hometown": "Copernicus City",
        "key": "one",
        "name": "Beverly"
      },
      {
        "key": "5feqybn7lb05",
        "value": ["Namaskāra", "hello", "marhabaan", "yeoboseyo"]
      },
      {
        "key": "jyesxxlrezo0",
        "value": "dude"
      }
    ]
  }
}

Update

Assume we have the following item in a Base:

{
  "key": "user-a",
  "username": "jimmy",
  "profile": {
    "age": 32,
    "active": false,
    "hometown": "pittsburgh"
  },
  "on_mobile": true,
  "likes": ["anime"],
  "purchases": 1
}

We will use update, via an updates dictionary / object.

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type Profile struct {
    Active   bool   `json:"active"`
    Age      int    `json:"age"`
    Hometown string `json:"hometown"`
}

type User struct {
    Key       string   `json:"key"`
    Username  string   `json:"username"`
    Profile   *Profile `json:"profile"`
    Purchases int      `json:"purchases"`
    Likes     []string `json:"likes"`
}

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    db, err := base.New(d, "users")
    if err != nil {
        fmt.Println("Failed to init new Base instance:", err)
    }

    // Define the updates.
    updates := base.Updates{
        "profile.age": 33, // Set "profile.age" to 33.
        "profile.active": true, // Set "profile.active" to true.
        "profile.hometown": db.Util.Trim(), // Remove "profile.hometown".
        "purchases": db.Util.Increment(2), // Increment "purchases" by 2.
        "likes": db.Util.Append("ramen"), // Append "ramen" to "likes".
    }
    // Update an item.
    err = db.Update("user-a", updates)
    if err != nil {
        fmt.Println("Failed to update item:", err)
        return
    }
}

const updates = {
  "profile.age": 33, // Set "profile.age" to 33.
  "profile.active": true, // Set "profile.active" to true.
  "profile.email": "[email protected]", // Create a new attribute "profile.email".
  "profile.hometown": users.util.trim(), // Remove "profile.hometown".
  on_mobile: users.util.trim(), // Remove "on_mobile".
  purchases: users.util.increment(2), // Increment "purchases" by 2.
  likes: users.util.append("ramen"), // Append "ramen" to "likes".
};

const res = await db.update(updates, "user-a");

updates = {
    "profile.age": 33,  # Set "profile.age" to 33.
    "profile.active": True,  # Set "profile.active" to true.
    "profile.email": "[email protected]",  # Create a new attribute "profile.email".
    "profile.hometown": users.util.trim(),  # Remove "profile.hometown".
    "on_mobile": users.util.trim(),  # Remove "on_mobile".
    "purchases": users.util.increment(2),  # Increment by 2.
    "likes": users.util.append("ramen"),  # Append "ramen" to "likes".
}

db.update(updates, "user-a")

updates = {
    "profile.age": 33,  # Set "profile.age" to 33.
    "profile.active": True,  # Set "profile.active" to true.
    "profile.email": "[email protected]",  # Create a new attribute "profile.email".
    "profile.hometown": users.util.trim(),  # Remove "profile.hometown".
    "on_mobile": users.util.trim(),  # Remove "on_mobile".
    "purchases": users.util.increment(2),  # Increment by 2.
    "likes": users.util.append("ramen"),  # Append "ramen" to "likes".
}

await db.update(updates, "user-a")

# Close db session
await db.close()

The above updates result in the following item in the Base:

{
  "key": "user-a",
  "username": "jimmy",
  "profile": {
    "age": 33,
    "active": true,
    "email": "[email protected]"
  },
  "likes": ["anime", "ramen"],
  "purchases": 3
}

Fetch

If we have the following items in a Base:

[
  {
    "key": "key-1",
    "name": "Wesley",
    "age": 27,
    "hometown": "San Francisco"
  },
  {
    "key": "key-2",
    "name": "Beverly",
    "age": 51,
    "hometown": "Copernicus City"
  },
  {
    "key": "key-3",
    "name": "Kevin Garnett",
    "age": 43,
    "hometown": "Greenville"
  }
]

Then the following fetch calls:

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type User struct {
    Key string `json:"key"`
    Name string `json:"name"`
    Age int `json:"age"`
    Hometown string `json:"hometown"`
}

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    db, err := base.New(d, "users")
    if err != nil {
        fmt.Println("Failed to init new Base instance:", err)
    }

    // Query to get users with age less than 30.
    query := base.Query{
        {"age?lt": 50},
    }

    // Declare a variable to store the results.
    var results []*User

    // Fetch items.
    _, err = db.Fetch(&base.FetchInput{
        Q:    query,
        Dest: &results,
    })
    if err != nil {
        fmt.Println("Failed to fetch items:", err)
    }
}

results will have the following data:

[
  {
    "key": "key-1",
    "name": "Wesley",
    "age": 27,
    "hometown": "San Francisco"
  },
  {
    "key": "key-3",
    "name": "Kevin Garnett",
    "age": 43,
    "hometown": "Greenville"
  }
]

const { items: firstResult } = await db.fetch({ "age?lt": 30 });
const { items: secondResult } = await db.fetch([{ "age?gt": 50 }, { hometown: "Greenville" }]);

will return following data:

firstResult:

[
  {
    "key": "key-1",
    "name": "Wesley",
    "age": 27,
    "hometown": "San Francisco"
  }
]

secondResult:

[
  {
    "key": "key-2",
    "name": "Beverly",
    "age": 51,
    "hometown": "Copernicus City"
  },
  {
    "key": "key-3",
    "name": "Kevin Garnett",
    "age": 43,
    "hometown": "Greenville"
  }
]

first_result = db.fetch({"age?lt": 30})
second_result = db.fetch([{"age?gt": 50}, {"hometown": "Greenville"}])

will return following data:

first_result.items:

[
  {
    "key": "key-1",
    "name": "Wesley",
    "age": 27,
    "hometown": "San Francisco"
  }
]

second_result.items:

[
  {
    "key": "key-2",
    "name": "Beverly",
    "age": 51,
    "hometown": "Copernicus City"
  },
  {
    "key": "key-3",
    "name": "Kevin Garnett",
    "age": 43,
    "hometown": "Greenville"
  }
]

first_result = await db.fetch({"age?lt": 30})
second_result = await db.fetch([{"age?gt": 50}, {"hometown": "Greenville"}])

# Close db session
await db.close()

will return following data:

first_result.items:

[
  {
    "key": "key-1",
    "name": "Wesley",
    "age": 27,
    "hometown": "San Francisco"
  }
]

second_result.items:

[
  {
    "key": "key-2",
    "name": "Beverly",
    "age": 51,
    "hometown": "Copernicus City"
  },
  {
    "key": "key-3",
    "name": "Kevin Garnett",
    "age": 43,
    "hometown": "Greenville"
  }
]

Fetch All Items

The following snippet will fetch all items from a Base:

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/base"
)

type User struct {
    Key      string   `json:"key"`
    Username string   `json:"username"`
    Active   bool     `json:"active"`
    Age      int      `json:"age"`
    Likes    []string `json:"likes"`
}

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    db, err := base.New(d, "users")
    if err != nil {
        fmt.Println("Failed to init new Base instance:", err)
    }

    // Query to get users with age less than 30.
    query := base.Query{
        {"age?lt": 50},
    }

    // Declare a variable to store the results.
    var results []*User

    // Declare a variable to store the page.
    var page []*User

    // Define fetch input.
    i := &base.FetchInput{
        Q:     query,
        Dest:  &page,
        Limit: 1, // Limit provided so each page will only have one item.
    }

    // Fetch items.
    lastKey, err := db.Fetch(i)
    if err != nil {
        fmt.Println("Failed to fetch items:", err)
        return
    }

    // Append the page items to the results.
    results = append(results, page...)

    // Get all pages.
    for lastKey != "" {
        // Provide the last key in the fetch input.
        i.LastKey = lastKey

        // Fetch items.
        lastKey, err = db.Fetch(i)
        if err != nil {
            fmt.Println("Failed to fetch items:", err)
            return
        }

        // Append the page items to the results.
        results = append(results, page...)
    }
}

let res = await db.fetch();
let allItems = res.items;

// Continue fetching until "res.last" is undefined.
while (res.last) {
  res = await db.fetch({}, { last: res.last });
  allItems = allItems.concat(res.items);
}

res = db.fetch()
all_items = res.items

# Continue fetching until "res.last" is None.
while res.last:
    res = db.fetch(last=res.last)
    all_items += res.items

res = await db.fetch()
all_items = res.items

# Continue fetching until "res.last" is None.
while res.last:
    res = await db.fetch(last=res.last)
    all_items += res.items

# Close db session
await db.close()

Drive

Put

import (
    "bufio"
    "fmt"
    "os"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/drive"
)

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    drawings, err := drive.New(d, "drawings")
    if err != nil {
        fmt.Println("Failed to init new Drive instance:", err)
        return
    }

    // Put a file from a local path.
    file, err := os.Open("./art.svg")
    defer file.Close()

    name, err := drawings.Put(&drive.PutInput{
        Name:        "art.svg",
        Body:        bufio.NewReader(file),
        ContentType: "image/svg+xml",
    })
    if err != nil {
        fmt.Println("Failed to put file:", err)
        return
    }
    fmt.Println("Successfully put file with name:", name)
}

// Provide content directly.
drive.put("hello.txt", {data: "Hello world"});
drive.put("hello.txt", {data: "Hello world", contentType: "text/plain"});

// Provide a content buffer.
drive.put("hello.txt", {data: Buffer.from("Hello World"), contentType: "text/plain"});

// Provide a path to a file.
drive.put("hello.txt", {path: "./my/file/path/file.txt"});
drive.put("hello.txt", {path: "./my/file/path/file.txt", contentType: "text/plain"});

# Provide content directly.
drive.put("hello.txt", "Hello world")
drive.put(b"hello.txt", "Hello world")
drive.put("hello.txt", content_type="text/plain")

import io

# Provide a file-like object.
drive.put("hello.txt", io.StringIO("hello world"))
drive.put("hello.txt", io.BytesIO(b"hello world"))

f = open("./hello.txt", "r")
drive.put("hello.txt", f)
f.close()

# Provide a path to a file.
drive.put("hello.txt", path="./hello.txt")

Get

const buf = await drive.get("hello.txt");

import (
    "fmt"
    "io/ioutil"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/drive"
)

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    drawings, err := drive.New(d, "drawings")
    if err != nil {
        fmt.Println("Failed to init new Drive instance:", err)
        return
    }

    // Get a file with a name.
    name := "art.svg"
    f, err := drawings.Get(name)
    if err != nil {
        fmt.Println("Failed to get file with name:", name)
        return
    }
    defer f.Close()

    // Read the file content.
    c, err := ioutil.ReadAll(f)
    if err != nil {
        fmt.Println("Failed read file content with err:", err)
        return
    }
    fmt.Println("File content:", string(c))
}

hello = drive.get("hello.txt")
content = hello.read()
hello.close()

# For a larger file, iterate chunks of size 4096 and save to disk.
large_file = drive.get("large_file.txt")
with open("large_file.txt", "wb+") as f:
    for chunk in large_file.iter_chunks(4096):
        f.write(chunk)
    large_file.close()

Delete

const deletedFile = await drive.delete("hello.txt");

deleted_file = drive.delete("hello.txt")

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/drive"
)

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    drawings, err := drive.New(d, "drawings")
    if err != nil {
        fmt.Println("Failed to init new Drive instance:", err)
        return
    }

    // Delete a file with a name.
    name, err := drawings.Delete("art.svg")
    if err != nil {
        fmt.Println("Failed to delete file with name:", name)
        return
    }
    fmt.Println("Successfully deleted file with name:", name)
}

Delete Many

const result = await drive.DeleteMany(["file1.txt", "file2.txt", "file3.txt"]);

result = drive.delete_many(["file1.txt", "file2.txt", "file3.txt"])

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/drive"
)

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    drawings, err := drive.New(d, "drawings")
    if err != nil {
        fmt.Println("Failed to init new Drive instance:", err)
        return
    }

    names := []string{"a", "b", "c"}
    dr, err := drawings.DeleteMany(names)

    if err != nil {
        fmt.Println("Failed to delete files", err)
        return
    }

    fmt.Println("Deleted:", dr.Deleted)
    fmt.Println("Failed:", dr.Failed)

}

An output includes a list / array of successfully deleted files, and a dict / object of failures with reasons:

{
  "deleted": ["file1.txt", "file2.txt"],
  "failed": {
    "file3.txt": "reason for failure"
  }
}

List

The following snippet will list all files in a Drive:

import (
    "fmt"

    "github.com/deta/deta-go/deta"
    "github.com/deta/deta-go/service/drive"
)

func main() {
    d, err := deta.New(deta.WithProjectKey("project_key"))
    if err != nil {
        fmt.Println("Failed to init new Deta instance:", err)
        return
    }

    drawings, err := drive.New(d, "drawings")
    if err != nil {
        fmt.Println("Failed to init new Drive instance:", err)
        return
    }

    lr, err := drawings.List(1000, "", "")
    if err != nil {
        fmt.Println("Failed to list names from drive with err:", err)
    }
    fmt.Println("Names:", lr.Names)
    // ["a", "b", "c/d"]

    lr, err = drawings.List(1, "", "")
    if err != nil {
        fmt.Println("Failed to list names from drive with err:", err)
    }
    fmt.Println("Names:", lr.Names)
    // ["a"]

    lr, err = drawings.List(2, "", "")
    if err != nil {
        fmt.Println("Failed to list names from drive with err:", err)
    }
    fmt.Println("Last:", *lr.Paging.Last)
    // "b"
}

let result = await drive.list();
let allFiles = result.names;
let last = result.paging.last;

while (last) {
  // Provide "last" from previous call.
  result = await drive.list({ last: result.paging.last });
  allFiles = allFiles.concat(result.names);
  last = result.paging.last;
}
console.log("all files:", allFiles);

const resultWithPrefix = await drive.list({ prefix: "blog/" });
const resultWithLimit = await drive.list({ limit: 100 });
const resultWithLimitAndPrefix = await drive.list({
  limit: 100,
  prefix: "blog/",
});

result = drive.list()
all_files = result.get("names")
last = result.get("paging", {}).get("last", None)

while last:
    # Provide "last" from previous call.
    result = drive.list(last=last)
    all_files += result.get("names")
    last = result.get("paging", {}).get("last", None)

print("all files:", all_files)

res_with_prefix = drive.list(prefix="/blog")
res_with_limit = drive.list(limit=100)
res_with_prefix_limit = drive.list(prefix="/blog", limit=100)

Outputs of list include a dict / object with paging and names keys.

{
  "names": ["file1.txt", "file2.txt"],
  "paging": {
    "size": 2,
    "last": "file2.txt"
  }
}

Drive

Types