Compare commits

...

1 Commits

Author SHA1 Message Date
Michaël Lemaire fd5d0c736f Use oak instead of opine 11 months ago
  1. 2
      .gitignore
  2. 48
      README.md
  3. 11
      cli.ts
  4. 6
      deps.server.ts
  5. 4
      deps.testing.ts
  6. 2
      deps.ts
  7. 3
      doc/about.md
  8. 15
      doc/import.md
  9. 3
      doc/index
  10. 27
      doc/use.md
  11. 59
      mod.ts
  12. 70
      server.ts
  13. 0
      src/basic.test.ts
  14. 2
      src/basic.ts
  15. 0
      src/local.test.ts
  16. 0
      src/local.ts
  17. 2
      src/main.test.ts
  18. 63
      src/main.ts
  19. 0
      src/remote.test.ts
  20. 0
      src/remote.ts
  21. 56
      src/server.ts
  22. 13
      src/testing.ts

2
.gitignore

@ -1,3 +1,5 @@
deno.d.ts
.vscode
.local
.output
web/*.js

48
README.md

@ -1,3 +1,51 @@
# typescript/storage
[![Build Status](https://thunderk.visualstudio.com/typescript/_apis/build/status/storage?branchName=master)](https://dev.azure.com/thunderk/typescript/_build?pipelineNameFilter=storage)
## About
Javascript/Typescript persistent storage, with key-value stores as foundation.
## Import
In deno:
```typescript
import { getLocalStorage } from "https://js.thunderk.net/storage/mod.ts";
```
In browser:
```html
<script type="module">
import { getLocalStorage } from "https://js.thunderk.net/storage/mod.js";
</script>
```
## Use
To get a storage locally persistent (saved in browser data or on disk for Deno):
```javascript
const storage = getLocalStorage("myapp");
await storage.get("key"); // => null
await storage.set("key", "value");
await storage.get("key"); // => "value"
```
To get a storage remotely persistent (saved on a compliant server):
```javascript
const storage = getRemoteStorage("myapp", "https://tk-storage.example.io/", {
shared: true,
});
await storage.get("key"); // => null
await storage.set("key", "value");
await storage.get("key"); // => "value"
```
Run a server for remote storage:
```shell
./cli.ts
```

11
cli.ts

@ -0,0 +1,11 @@
#!./run
import { getLocalStorage } from "./src/main.ts";
import { startRestServer } from "./src/server.ts";
const PORT = 5001;
if (import.meta.main) {
await startRestServer(PORT, getLocalStorage("tk-storage-server"));
console.log(`Server running, use http://localhost:${PORT} to connect`);
}

6
deps.server.ts

@ -1,4 +1,4 @@
export { readAll } from "https://deno.land/std@0.104.0/io/util.ts";
export { readAll } from "https://deno.land/std@0.107.0/io/util.ts";
export { json, opine } from "https://deno.land/x/opine@1.7.2/mod.ts";
export { opineCors } from "https://deno.land/x/cors@v1.2.2/mod.ts";
export { Application } from "https://deno.land/x/oak@v9.0.1/mod.ts";
export { oakCors } from "https://deno.land/x/cors@v1.2.2/mod.ts";

4
deps.testing.ts

@ -2,6 +2,4 @@ export {
describe,
expect,
it,
} from "https://js.thunderk.net/devtools@1.3.0/testing.ts";
export { getAvailablePort } from "https://deno.land/x/port@1.0.0/mod.ts";
} from "https://js.thunderk.net/testing@1.0.0/mod.ts";

2
deps.ts

@ -1 +1 @@
export { v1 as uuid1 } from "https://deno.land/std@0.104.0/uuid/mod.ts";
export { v1 as uuid1 } from "https://deno.land/std@0.107.0/uuid/mod.ts";

3
doc/about.md

@ -0,0 +1,3 @@
## About
Javascript/Typescript persistent storage, with key-value stores as foundation.

15
doc/import.md

@ -0,0 +1,15 @@
## Import
In deno:
```typescript
import { getLocalStorage } from "https://js.thunderk.net/storage/mod.ts";
```
In browser:
```html
<script type="module">
import { getLocalStorage } from "https://js.thunderk.net/storage/mod.js";
</script>
```

3
doc/index

@ -0,0 +1,3 @@
about
import
use

27
doc/use.md

@ -0,0 +1,27 @@
## Use
To get a storage locally persistent (saved in browser data or on disk for Deno):
```javascript
const storage = getLocalStorage("myapp");
await storage.get("key"); // => null
await storage.set("key", "value");
await storage.get("key"); // => "value"
```
To get a storage remotely persistent (saved on a compliant server):
```javascript
const storage = getRemoteStorage("myapp", "https://tk-storage.example.io/", {
shared: true,
});
await storage.get("key"); // => null
await storage.set("key", "value");
await storage.get("key"); // => "value"
```
Run a server for remote storage:
```shell
./cli.ts
```

59
mod.ts

@ -3,61 +3,24 @@ import {
MemoryStorage,
RefScopedStorage,
ScopedStorage,
} from "./basic.ts";
import { LocalStorage } from "./local.ts";
import { RestRemoteStorage } from "./remote.ts";
} from "./src/basic.ts";
import {
getLocalStorage,
getMemoryStorage,
getRemoteStorage,
} from "./src/main.ts";
import { LocalStorage } from "./src/local.ts";
import { RestRemoteStorage } from "./src/remote.ts";
/**
* Base type for storage usage
*/
export type TKStorage = KeyValueStorage;
/**
* Exposed classes
*/
export {
getLocalStorage,
getMemoryStorage,
getRemoteStorage,
LocalStorage,
MemoryStorage,
RefScopedStorage,
RestRemoteStorage,
ScopedStorage,
};
/**
* Get the best "local" storage available
*/
export function getLocalStorage(appname: string): TKStorage {
try {
return new ScopedStorage(new LocalStorage(), appname);
} catch {
console.warn(
"No persistent storage available, using in-memory volatile storage",
);
return new MemoryStorage();
}
}
/**
* Get a remote storage, based on an URI
*
* If *shared* is set to true, a namespace will be used to avoid collisions, using getLocalStorage to persist it
*/
export function getRemoteStorage(
appname: string,
uri: string,
options = { shared: false },
): TKStorage {
let storage: TKStorage = new RestRemoteStorage(appname, uri);
storage = new ScopedStorage(storage, appname);
if (options.shared) {
storage = new RefScopedStorage(getLocalStorage(appname), storage);
}
return storage;
}
/**
* Get a in-memory volatile storage
*/
export function getMemoryStorage(): TKStorage {
return new MemoryStorage();
}

70
server.ts

@ -1,70 +0,0 @@
#!./run
import { KeyValueStorage } from "./basic.ts";
import { json, opine, opineCors, readAll } from "./deps.server.ts";
import { getLocalStorage } from "./mod.ts";
import { HEADER_REPLYIER, HEADER_REQUESTER } from "./remote.ts";
const PORT = 5001;
type Server = {
close: () => Promise<void>;
};
/**
* Start a server compliant with RestRemoteStorage
*/
export function startRestServer(
port: number,
storage: KeyValueStorage,
): Promise<Server> {
const app = opine();
app.use(
opineCors({ exposedHeaders: [HEADER_REPLYIER] }),
json(),
(req, res, next) => {
if (req.get(HEADER_REQUESTER)) {
res.set(HEADER_REPLYIER, "ok");
next();
} else {
res.setStatus(400).send();
}
},
);
app.get("*", (req, res, next) => {
storage.get(req.path).then((result) => {
if (result === null) {
res.setStatus(404).send();
} else {
res.send(result);
}
}).catch(next);
});
app.put("*", (req, res, next) => {
readAll(req.body).then((body) => {
const value = new TextDecoder().decode(body);
storage.set(req.path, value).then(() => {
res.send();
}).catch(next);
}).catch(next);
});
app.delete("*", (req, res, next) => {
storage.set(req.path, null).then(() => {
res.send();
}).catch(next);
});
return new Promise((resolve) => {
const server = app.listen(port, () => {
resolve({
close: async () => {
server.close();
},
});
});
});
}
if (import.meta.main) {
await startRestServer(PORT, getLocalStorage("tk-storage-server"));
console.log(`Server running, use http://localhost:${PORT} to connect`);
}

0
basic.test.ts → src/basic.test.ts

2
basic.ts → src/basic.ts

@ -1,4 +1,4 @@
import { uuid1 } from "./deps.ts";
import { uuid1 } from "../deps.ts";
/**
* Standard interface for the simplest key-value store

0
local.test.ts → src/local.test.ts

0
local.ts → src/local.ts

2
mod.test.ts → src/main.test.ts

@ -1,4 +1,4 @@
import { getLocalStorage, getMemoryStorage, getRemoteStorage } from "./mod.ts";
import { getLocalStorage, getMemoryStorage, getRemoteStorage } from "./main.ts";
import { MemoryStorage, ScopedStorage } from "./basic.ts";
import { describe, expect, it, runTestServer } from "./testing.ts";

63
src/main.ts

@ -0,0 +1,63 @@
import {
KeyValueStorage,
MemoryStorage,
RefScopedStorage,
ScopedStorage,
} from "./basic.ts";
import { LocalStorage } from "./local.ts";
import { RestRemoteStorage } from "./remote.ts";
/**
* Base type for storage usage
*/
export type TKStorage = KeyValueStorage;
/**
* Exposed classes
*/
export {
LocalStorage,
MemoryStorage,
RefScopedStorage,
RestRemoteStorage,
ScopedStorage,
};
/**
* Get the best "local" storage available
*/
export function getLocalStorage(appname: string): TKStorage {
try {
return new ScopedStorage(new LocalStorage(), appname);
} catch {
console.warn(
"No persistent storage available, using in-memory volatile storage",
);
return new MemoryStorage();
}
}
/**
* Get a remote storage, based on an URI
*
* If *shared* is set to true, a namespace will be used to avoid collisions, using getLocalStorage to persist it
*/
export function getRemoteStorage(
appname: string,
uri: string,
options = { shared: false },
): TKStorage {
let storage: TKStorage = new RestRemoteStorage(appname, uri);
storage = new ScopedStorage(storage, appname);
if (options.shared) {
storage = new RefScopedStorage(getLocalStorage(appname), storage);
}
return storage;
}
/**
* Get a in-memory volatile storage
*/
export function getMemoryStorage(): TKStorage {
return new MemoryStorage();
}

0
remote.test.ts → src/remote.test.ts

0
remote.ts → src/remote.ts

56
src/server.ts

@ -0,0 +1,56 @@
import { KeyValueStorage } from "./basic.ts";
import { Application, oakCors, readAll } from "../deps.server.ts";
import { HEADER_REPLYIER, HEADER_REQUESTER } from "./remote.ts";
type Server = {
close: () => Promise<void>;
};
/**
* Start a server compliant with RestRemoteStorage
*/
export function startRestServer(
port: number,
storage: KeyValueStorage,
): Server {
const app = new Application();
const controller = new AbortController();
app.use(oakCors());
app.use(async (context) => {
if (context.request.headers.get(HEADER_REQUESTER)) {
context.response.headers.set(HEADER_REPLYIER, "ok");
const method = context.request.method;
const path = context.request.url.pathname;
if (method == "GET") {
const result = await storage.get(path);
if (result === null) {
context.response.status = 404;
} else {
context.response.body = result;
}
} else if (method == "PUT") {
const body = context.request.body({ type: "reader" });
const data = await readAll(body.value);
const value = new TextDecoder().decode(data);
await storage.set(path, value);
} else if (method == "DELETE") {
await storage.set(path, null);
} else {
context.response.status = 405;
}
} else {
context.response.status = 400;
}
});
const listen = app.listen({ port, signal: controller.signal });
return {
close: async () => {
controller.abort();
await listen;
},
};
}

13
testing.ts → src/testing.ts

@ -1,9 +1,11 @@
import { KeyValueStorage, MemoryStorage } from "./basic.ts";
import { startRestServer } from "./server.ts";
import { describe, expect, getAvailablePort, it } from "./deps.testing.ts";
import { describe, expect, it } from "../deps.testing.ts";
export { describe, expect, it };
const PORT = 5002;
/**
* Basic high-level test suite for any kind storage
*/
@ -39,14 +41,9 @@ export async function disableLocalStorage(
export async function runTestServer(
body: (url: string) => Promise<void>,
): Promise<void> {
const port = await getAvailablePort({ port: { start: 3000, end: 30000 } });
if (!port) {
throw new Error("No port available for test server");
}
const app = await startRestServer(port, new MemoryStorage());
const app = await startRestServer(PORT, new MemoryStorage());
try {
await body(`http://localhost:${port}`);
await body(`http://localhost:${PORT}`);
} finally {
await app.close();
}
Loading…
Cancel
Save