@kokuin/expo 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+# @kokuin/expo
+
+## Installation
+
+```sh
+npm install @kokuin/expo
+```

package/lib/entry.d.ts

@@ -0,0 +1,15 @@
+import type { KeyEntry } from '@kokuin/token';
+import * as SecureStore from 'expo-secure-store';
+export type StoreEntryOptions = SecureStore.SecureStoreOptions;
+export declare class ExpoKeyEntry implements KeyEntry<Uint8Array> {
+    #private;
+    constructor(keyID: string, options?: StoreEntryOptions);
+    get keyID(): string;
+    get(): Uint8Array | null;
+    getAsync(): Promise<Uint8Array | null>;
+    set(privateKey: Uint8Array): void;
+    setAsync(privateKey: Uint8Array): Promise<void>;
+    provide(): Uint8Array;
+    provideAsync(): Promise<Uint8Array>;
+    removeAsync(): Promise<void>;
+}

package/lib/entry.js

@@ -0,0 +1,49 @@
+import { fromB64, toB64 } from '@sozai/codec';
+import * as SecureStore from 'expo-secure-store';
+import { randomPrivateKey, randomPrivateKeyAsync } from './utils.js';
+export class ExpoKeyEntry {
+    #keyID;
+    #options;
+    constructor(keyID, options){
+        this.#keyID = keyID;
+        this.#options = options;
+    }
+    get keyID() {
+        return this.#keyID;
+    }
+    get() {
+        const privateKey = SecureStore.getItem(this.#keyID, this.#options);
+        return privateKey ? fromB64(privateKey) : null;
+    }
+    async getAsync() {
+        const privateKey = await SecureStore.getItemAsync(this.#keyID, this.#options);
+        return privateKey ? fromB64(privateKey) : null;
+    }
+    set(privateKey) {
+        SecureStore.setItem(this.#keyID, toB64(privateKey), this.#options);
+    }
+    async setAsync(privateKey) {
+        await SecureStore.setItemAsync(this.#keyID, toB64(privateKey), this.#options);
+    }
+    provide() {
+        const existing = this.get();
+        if (existing != null) {
+            return existing;
+        }
+        const privateKey = randomPrivateKey();
+        this.set(privateKey);
+        return privateKey;
+    }
+    async provideAsync() {
+        const existing = await this.getAsync();
+        if (existing != null) {
+            return existing;
+        }
+        const privateKey = await randomPrivateKeyAsync();
+        await this.setAsync(privateKey);
+        return privateKey;
+    }
+    async removeAsync() {
+        await SecureStore.deleteItemAsync(this.#keyID, this.#options);
+    }
+}

package/lib/identity.d.ts

@@ -0,0 +1,3 @@
+import { type FullIdentity } from '@kokuin/token';
+export declare function provideFullIdentity(keyID: string): FullIdentity;
+export declare function provideFullIdentityAsync(keyID: string): Promise<FullIdentity>;

package/lib/identity.js

@@ -0,0 +1,57 @@
+import { createFullIdentity } from '@kokuin/token';
+import { getLogger } from '@sozai/log';
+import { AttributeKeys, createTracer, SpanNames, withSpan, withSyncSpan } from '@sozai/otel';
+import { ExpoKeyStore } from './store.js';
+const tracer = createTracer('keystore.expo');
+const logger = getLogger([
+    'kokuin',
+    'expo'
+]);
+export function provideFullIdentity(keyID) {
+    return withSyncSpan(tracer, SpanNames.KEYSTORE_GET_OR_CREATE, {
+        attributes: {
+            [AttributeKeys.KEYSTORE_STORE_TYPE]: 'expo'
+        }
+    }, (span)=>{
+        const entry = ExpoKeyStore.entry(keyID);
+        const existing = entry.get();
+        if (existing != null) {
+            const identity = createFullIdentity(existing);
+            span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+            span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, false);
+            return identity;
+        }
+        const key = entry.provide();
+        const identity = createFullIdentity(key);
+        span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+        span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, true);
+        logger.info('New identity generated: {did}', {
+            did: identity.id
+        });
+        return identity;
+    });
+}
+export async function provideFullIdentityAsync(keyID) {
+    return withSpan(tracer, SpanNames.KEYSTORE_GET_OR_CREATE, {
+        attributes: {
+            [AttributeKeys.KEYSTORE_STORE_TYPE]: 'expo'
+        }
+    }, async (span)=>{
+        const entry = ExpoKeyStore.entry(keyID);
+        const existing = await entry.getAsync();
+        if (existing != null) {
+            const identity = createFullIdentity(existing);
+            span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+            span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, false);
+            return identity;
+        }
+        const key = await entry.provideAsync();
+        const identity = createFullIdentity(key);
+        span.setAttribute(AttributeKeys.AUTH_DID, identity.id);
+        span.setAttribute(AttributeKeys.KEYSTORE_KEY_CREATED, true);
+        logger.info('New identity generated: {did}', {
+            did: identity.id
+        });
+        return identity;
+    });
+}

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Key store for React Native.
+ *
+ * ## Installation
+ *
+ * ```sh
+ * npm install @kokuin/expo
+ * ```
+ *
+ * @module expo-keystore
+ */
+export { ExpoKeyEntry } from './entry.js';
+export { provideFullIdentity, provideFullIdentityAsync } from './identity.js';
+export { ExpoKeyStore } from './store.js';
+export { randomPrivateKey, randomPrivateKeyAsync } from './utils.js';

package/lib/index.js

@@ -0,0 +1,14 @@
+/**
+ * Key store for React Native.
+ *
+ * ## Installation
+ *
+ * ```sh
+ * npm install @kokuin/expo
+ * ```
+ *
+ * @module expo-keystore
+ */ export { ExpoKeyEntry } from './entry.js';
+export { provideFullIdentity, provideFullIdentityAsync } from './identity.js';
+export { ExpoKeyStore } from './store.js';
+export { randomPrivateKey, randomPrivateKeyAsync } from './utils.js';

package/lib/store.d.ts

@@ -0,0 +1,3 @@
+import type { KeyStore } from '@kokuin/token';
+import { ExpoKeyEntry } from './entry.js';
+export declare const ExpoKeyStore: KeyStore<Uint8Array, ExpoKeyEntry>;

package/lib/store.js

@@ -0,0 +1,6 @@
+import { ExpoKeyEntry } from './entry.js';
+export const ExpoKeyStore = {
+    entry: (keyID, options)=>{
+        return new ExpoKeyEntry(keyID, options);
+    }
+};

package/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function randomPrivateKey(): Uint8Array;
+export declare function randomPrivateKeyAsync(): Promise<Uint8Array>;

package/lib/utils.js

@@ -0,0 +1,7 @@
+import { getRandomBytes, getRandomBytesAsync } from 'expo-crypto';
+export function randomPrivateKey() {
+    return getRandomBytes(32);
+}
+export function randomPrivateKeyAsync() {
+    return getRandomBytesAsync(32);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@kokuin/expo",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Key store for React Native",
+  "keywords": [
+    "cryptography",
+    "key-management",
+    "react-native",
+    "expo",
+    "storage"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TairuFramework/kokuin",
+    "directory": "packages/expo"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/*"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@sozai/codec": "^0.1.0",
+    "@sozai/log": "^0.1.0",
+    "@sozai/otel": "^0.1.0",
+    "expo-crypto": "^56.0.4",
+    "expo-secure-store": "^56.0.4",
+    "@kokuin/token": "^0.1.0"
+  },
+  "scripts": {
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
+    "test:unit": "vitest run",
+    "test": "pnpm run test:types && pnpm run test:unit"
+  }
+}