@kokuin/expo 0.2.1 → 0.3.1

package/lib/entry.d.ts

@@ -1,9 +1,13 @@
-import type { KeyEntry } from '@kokuin/token';
+import type { MutableKeyEntry } from '@kokuin/token';
 import * as SecureStore from 'expo-secure-store';
 export type StoreEntryOptions = SecureStore.SecureStoreOptions;
-export declare class ExpoKeyEntry implements KeyEntry<Uint8Array> {
+export type ExpoKeyEntryParams = {
+    keyID: string;
+    options?: StoreEntryOptions;
+};
+export declare class ExpoKeyEntry implements MutableKeyEntry<Uint8Array> {
     #private;
-    constructor(keyID: string, options?: StoreEntryOptions);
+    constructor(params: ExpoKeyEntryParams);
     get keyID(): string;
     get(): Uint8Array | null;
     getAsync(): Promise<Uint8Array | null>;
@@ -11,5 +15,10 @@ export declare class ExpoKeyEntry implements KeyEntry<Uint8Array> {
     setAsync(privateKey: Uint8Array): Promise<void>;
     provide(): Uint8Array;
     provideAsync(): Promise<Uint8Array>;
+    /**
+     * Delete the key. `expo-secure-store` has no synchronous delete, so this starts the deletion
+     * and returns immediately — use {@link removeAsync} when you need to know it completed.
+     */
+    remove(): void;
     removeAsync(): Promise<void>;
 }

package/lib/entry.js

@@ -1,12 +1,20 @@
 import { fromB64, toB64 } from '@sozai/codec';
+import { getLogger } from '@sozai/log';
 import * as SecureStore from 'expo-secure-store';
 import { randomPrivateKey, randomPrivateKeyAsync } from './utils.js';
+const logger = getLogger([
+    'kokuin',
+    'expo'
+]);
 export class ExpoKeyEntry {
     #keyID;
     #options;
-    constructor(keyID, options){
-        this.#keyID = keyID;
-        this.#options = options;
+    // Serializes provideAsync within this process. Expo runs a single app process, so there is
+    // no cross-process race to guard — unlike node and electron.
+    #provideLock = Promise.resolve();
+    constructor(params){
+        this.#keyID = params.keyID;
+        this.#options = params.options;
     }
     get keyID() {
         return this.#keyID;
@@ -34,14 +42,29 @@ export class ExpoKeyEntry {
         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;
+    provideAsync() {
+        const run = this.#provideLock.then(async ()=>{
+            const existing = await this.getAsync();
+            if (existing != null) {
+                return existing;
+            }
+            const privateKey = await randomPrivateKeyAsync();
+            await this.setAsync(privateKey);
+            return privateKey;
+        });
+        this.#provideLock = run.catch(()=>undefined);
+        return run;
+    }
+    /**
+   * Delete the key. `expo-secure-store` has no synchronous delete, so this starts the deletion
+   * and returns immediately — use {@link removeAsync} when you need to know it completed.
+   */ remove() {
+        SecureStore.deleteItemAsync(this.#keyID, this.#options).catch((error)=>{
+            logger.warn('Failed to remove key {keyID}: {error}', {
+                keyID: this.#keyID,
+                error
+            });
+        });
     }
     async removeAsync() {
         await SecureStore.deleteItemAsync(this.#keyID, this.#options);

package/lib/index.d.ts

@@ -9,7 +9,6 @@
  *
  * @module expo-keystore
  */
-export { ExpoKeyEntry } from './entry.js';
-export { provideFullIdentity, provideFullIdentityAsync } from './identity.js';
+export { ExpoKeyEntry, type ExpoKeyEntryParams, type StoreEntryOptions } from './entry.js';
 export { ExpoKeyStore } from './store.js';
 export { randomPrivateKey, randomPrivateKeyAsync } from './utils.js';

package/lib/index.js

@@ -9,6 +9,5 @@
  *
  * @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

@@ -1,3 +1,19 @@
-import type { KeyStore } from '@kokuin/token';
-import { ExpoKeyEntry } from './entry.js';
-export declare const ExpoKeyStore: KeyStore<Uint8Array, ExpoKeyEntry>;
+import { type FullIdentity, type IdentityProvider, type KeyStore } from '@kokuin/token';
+import { ExpoKeyEntry, type StoreEntryOptions } from './entry.js';
+export declare class ExpoKeyStore implements KeyStore<Uint8Array, ExpoKeyEntry>, IdentityProvider<FullIdentity> {
+    #private;
+    /** The process-wide store. `options` apply to every entry it creates. */
+    static open(options?: StoreEntryOptions): ExpoKeyStore;
+    constructor(options?: StoreEntryOptions);
+    /**
+     * The entry for `keyID`, cached — `entry(x) === entry(x)`.
+     *
+     * The old object-literal store created a fresh entry per call, which silently defeated the
+     * per-entry `provideAsync` lock, and took an undeclared second `options` argument that the
+     * `KeyStore` type does not have. Options now belong to the store.
+     */
+    entry(keyID: string): ExpoKeyEntry;
+    provideIdentity(keyID: string): Promise<FullIdentity>;
+    /** {@link provideIdentity}, synchronously. Beyond the `IdentityProvider` contract. */
+    provideIdentitySync(keyID: string): FullIdentity;
+}

package/lib/store.js

@@ -1,6 +1,75 @@
+import { createTracer, KokuinAttributeKeys, KokuinSpanNames } from '@kokuin/otel';
+import { createFullIdentity } from '@kokuin/token';
+import { getLogger } from '@sozai/log';
+import { withSpan, withSyncSpan } from '@sozai/otel';
 import { ExpoKeyEntry } from './entry.js';
-export const ExpoKeyStore = {
-    entry: (keyID, options)=>{
-        return new ExpoKeyEntry(keyID, options);
+const tracer = createTracer('keystore.expo');
+const logger = getLogger([
+    'kokuin',
+    'expo'
+]);
+export class ExpoKeyStore {
+    static #default;
+    /** The process-wide store. `options` apply to every entry it creates. */ static open(options) {
+        ExpoKeyStore.#default ??= new ExpoKeyStore(options);
+        return ExpoKeyStore.#default;
     }
-};
+    #entries = Object.create(null);
+    #options;
+    constructor(options){
+        this.#options = options;
+    }
+    /**
+   * The entry for `keyID`, cached — `entry(x) === entry(x)`.
+   *
+   * The old object-literal store created a fresh entry per call, which silently defeated the
+   * per-entry `provideAsync` lock, and took an undeclared second `options` argument that the
+   * `KeyStore` type does not have. Options now belong to the store.
+   */ entry(keyID) {
+        this.#entries[keyID] ??= new ExpoKeyEntry({
+            keyID,
+            options: this.#options
+        });
+        return this.#entries[keyID];
+    }
+    async provideIdentity(keyID) {
+        return withSpan(tracer, KokuinSpanNames.KEYSTORE_GET_OR_CREATE, {
+            attributes: {
+                [KokuinAttributeKeys.KEYSTORE_STORE_TYPE]: 'expo'
+            }
+        }, async (span)=>{
+            const entry = this.entry(keyID);
+            const existing = await entry.getAsync();
+            const privateKey = existing ?? await entry.provideAsync();
+            const identity = createFullIdentity(privateKey);
+            span.setAttribute(KokuinAttributeKeys.AUTH_DID, identity.id);
+            span.setAttribute(KokuinAttributeKeys.KEYSTORE_KEY_CREATED, existing == null);
+            if (existing == null) {
+                logger.info('New identity generated: {did}', {
+                    did: identity.id
+                });
+            }
+            return identity;
+        });
+    }
+    /** {@link provideIdentity}, synchronously. Beyond the `IdentityProvider` contract. */ provideIdentitySync(keyID) {
+        return withSyncSpan(tracer, KokuinSpanNames.KEYSTORE_GET_OR_CREATE, {
+            attributes: {
+                [KokuinAttributeKeys.KEYSTORE_STORE_TYPE]: 'expo'
+            }
+        }, (span)=>{
+            const entry = this.entry(keyID);
+            const existing = entry.get();
+            const privateKey = existing ?? entry.provide();
+            const identity = createFullIdentity(privateKey);
+            span.setAttribute(KokuinAttributeKeys.AUTH_DID, identity.id);
+            span.setAttribute(KokuinAttributeKeys.KEYSTORE_KEY_CREATED, existing == null);
+            if (existing == null) {
+                logger.info('New identity generated: {did}', {
+                    did: identity.id
+                });
+            }
+            return identity;
+        });
+    }
+}

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@kokuin/expo",
-  "version": "0.2.1",
-  "license": "MIT",
+  "version": "0.3.1",
   "description": "Key store for React Native",
   "keywords": [
     "cryptography",
@@ -15,32 +14,39 @@
     "url": "https://github.com/TairuFramework/kokuin",
     "directory": "packages/expo"
   },
+  "license": "MIT",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@sozai/codec": "^0.2.0",
-    "@sozai/log": "^0.1.0",
-    "@sozai/otel": "^0.2.0",
-    "expo-crypto": "^57.0.0",
-    "expo-secure-store": "^57.0.0",
-    "@kokuin/otel": "^0.1.0",
-    "@kokuin/token": "^0.2.0"
+    "@sozai/codec": "^0.4.0",
+    "@sozai/log": "^0.3.1",
+    "@sozai/otel": "^0.3.2",
+    "expo-crypto": "^57.0.1",
+    "expo-secure-store": "^57.0.1",
+    "@kokuin/otel": "^0.3.0",
+    "@kokuin/token": "^0.4.0"
+  },
+  "devDependencies": {
+    "@kokuin/keystore-conformance": "^0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "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": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }

package/lib/identity.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,58 +0,0 @@
-import { createTracer, KokuinAttributeKeys, KokuinSpanNames } from '@kokuin/otel';
-import { createFullIdentity } from '@kokuin/token';
-import { getLogger } from '@sozai/log';
-import { 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, KokuinSpanNames.KEYSTORE_GET_OR_CREATE, {
-        attributes: {
-            [KokuinAttributeKeys.KEYSTORE_STORE_TYPE]: 'expo'
-        }
-    }, (span)=>{
-        const entry = ExpoKeyStore.entry(keyID);
-        const existing = entry.get();
-        if (existing != null) {
-            const identity = createFullIdentity(existing);
-            span.setAttribute(KokuinAttributeKeys.AUTH_DID, identity.id);
-            span.setAttribute(KokuinAttributeKeys.KEYSTORE_KEY_CREATED, false);
-            return identity;
-        }
-        const key = entry.provide();
-        const identity = createFullIdentity(key);
-        span.setAttribute(KokuinAttributeKeys.AUTH_DID, identity.id);
-        span.setAttribute(KokuinAttributeKeys.KEYSTORE_KEY_CREATED, true);
-        logger.info('New identity generated: {did}', {
-            did: identity.id
-        });
-        return identity;
-    });
-}
-export async function provideFullIdentityAsync(keyID) {
-    return withSpan(tracer, KokuinSpanNames.KEYSTORE_GET_OR_CREATE, {
-        attributes: {
-            [KokuinAttributeKeys.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(KokuinAttributeKeys.AUTH_DID, identity.id);
-            span.setAttribute(KokuinAttributeKeys.KEYSTORE_KEY_CREATED, false);
-            return identity;
-        }
-        const key = await entry.provideAsync();
-        const identity = createFullIdentity(key);
-        span.setAttribute(KokuinAttributeKeys.AUTH_DID, identity.id);
-        span.setAttribute(KokuinAttributeKeys.KEYSTORE_KEY_CREATED, true);
-        logger.info('New identity generated: {did}', {
-            did: identity.id
-        });
-        return identity;
-    });
-}