@gasboost/auth 0.1.0

package/dist/domain/PasswordReset.d.ts

@@ -0,0 +1,25 @@
+export declare class PasswordReset {
+    readonly id: string;
+    readonly accountId: string;
+    readonly tokenHash: string;
+    readonly expiresAt: Date;
+    readonly enabled: boolean;
+    constructor({ id, accountId, tokenHash, expiresAt, enabled, }: {
+        id: string;
+        accountId: string;
+        tokenHash: string;
+        expiresAt: Date;
+        enabled: boolean;
+    });
+    static create({ accountId, utilities, expiresAt, }: {
+        accountId: string;
+        utilities: GoogleAppsScript.Utilities.Utilities;
+        expiresAt: Date;
+    }): {
+        reset: PasswordReset;
+        token: string;
+    };
+    verify(token: string, utilities: GoogleAppsScript.Utilities.Utilities): boolean;
+    isExpired(now: Date): boolean;
+    disable(): PasswordReset;
+}

package/dist/domain/PasswordReset.js

@@ -0,0 +1,44 @@
+import { PasswordResetToken } from "./PasswordResetToken";
+export class PasswordReset {
+    id;
+    accountId;
+    tokenHash;
+    expiresAt;
+    enabled;
+    constructor({ id, accountId, tokenHash, expiresAt, enabled, }) {
+        this.id = id;
+        this.accountId = accountId;
+        this.tokenHash = tokenHash;
+        this.expiresAt = expiresAt;
+        this.enabled = enabled;
+    }
+    static create({ accountId, utilities, expiresAt, }) {
+        const token = PasswordResetToken.generate(utilities);
+        return {
+            token: token.value,
+            reset: new PasswordReset({
+                id: utilities.getUuid(),
+                accountId,
+                tokenHash: token.hash(utilities),
+                expiresAt,
+                enabled: true,
+            }),
+        };
+    }
+    verify(token, utilities) {
+        const tokenHash = new PasswordResetToken(token).hash(utilities);
+        return tokenHash === this.tokenHash;
+    }
+    isExpired(now) {
+        return this.expiresAt.getTime() <= now.getTime();
+    }
+    disable() {
+        return new PasswordReset({
+            id: this.id,
+            accountId: this.accountId,
+            tokenHash: this.tokenHash,
+            expiresAt: this.expiresAt,
+            enabled: false,
+        });
+    }
+}

package/dist/domain/PasswordResetToken.d.ts

@@ -0,0 +1,6 @@
+export declare class PasswordResetToken {
+    readonly value: string;
+    constructor(value: string);
+    static generate(utilities: GoogleAppsScript.Utilities.Utilities): PasswordResetToken;
+    hash(utilities: GoogleAppsScript.Utilities.Utilities): string;
+}

package/dist/domain/PasswordResetToken.js

@@ -0,0 +1,17 @@
+export class PasswordResetToken {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static generate(utilities) {
+        const token = utilities.getUuid();
+        return new PasswordResetToken(token);
+    }
+    hash(utilities) {
+        const tokenHash = utilities
+            .computeDigest(utilities.DigestAlgorithm.SHA_256, this.value)
+            .map((b) => ("00" + (b & 0xff).toString(16)).slice(-2))
+            .join("");
+        return tokenHash;
+    }
+}

package/dist/domain/Session.d.ts

@@ -0,0 +1,14 @@
+export type SessionId = string;
+export declare class Session {
+    readonly id: SessionId;
+    readonly userId: string;
+    readonly createdAt: Date;
+    readonly expiresAt: Date;
+    constructor({ id, userId, createdAt, expiresAt, }: {
+        id: SessionId;
+        userId: string;
+        createdAt: Date;
+        expiresAt: Date;
+    });
+    isExpired(now: Date): boolean;
+}

package/dist/domain/Session.js

@@ -0,0 +1,15 @@
+export class Session {
+    id;
+    userId;
+    createdAt;
+    expiresAt;
+    constructor({ id, userId, createdAt, expiresAt, }) {
+        this.id = id;
+        this.userId = userId;
+        this.createdAt = createdAt;
+        this.expiresAt = expiresAt;
+    }
+    isExpired(now) {
+        return now > this.expiresAt;
+    }
+}

package/dist/domain/User.d.ts

@@ -0,0 +1,13 @@
+import { AuthPattern } from "../AuthPattern";
+import type { Account } from "./Account";
+export declare class User {
+    readonly id: string;
+    readonly name: string;
+    readonly accounts: Account[];
+    constructor({ id, name, accounts, }: {
+        id: string;
+        name: string;
+        accounts: Account[];
+    });
+    account(provider: AuthPattern): Account | null;
+}

package/dist/domain/User.js

@@ -0,0 +1,13 @@
+export class User {
+    id;
+    name;
+    accounts;
+    constructor({ id, name, accounts, }) {
+        this.id = id;
+        this.name = name;
+        this.accounts = accounts;
+    }
+    account(provider) {
+        return (this.accounts.find((account) => account.identity.providerName === provider) || null);
+    }
+}

package/dist/factory/sessionStorageFactory.d.ts

@@ -0,0 +1,6 @@
+import type { AppsScriptSessionStorage } from "../storage/AppsScriptSessionStorage";
+export type SessionStorageType = "properties" | "cache";
+export declare function sessionStorageFactory(storage: SessionStorageType, { cacheService, propertiesService, }: {
+    cacheService: GoogleAppsScript.Cache.CacheService;
+    propertiesService: GoogleAppsScript.Properties.PropertiesService;
+}): AppsScriptSessionStorage;

package/dist/factory/sessionStorageFactory.js

@@ -0,0 +1,11 @@
+import { AppsScriptCacheSessionStorage } from "../storage/AppsScriptCacheSessionStorage";
+import { AppsScriptPropertiesSessionStorage } from "../storage/AppsScriptPropertiesSessionStorage";
+export function sessionStorageFactory(storage, { cacheService, propertiesService, }) {
+    if (storage === "properties") {
+        return new AppsScriptPropertiesSessionStorage(propertiesService.getScriptProperties());
+    }
+    if (storage === "cache") {
+        return new AppsScriptCacheSessionStorage(cacheService.getScriptCache());
+    }
+    throw new Error("Invalid storage type");
+}

package/dist/identity/AppsScriptIdentity.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderIdentity } from "./ProviderIdentity";
+export declare class AppsScriptIdentity implements ProviderIdentity {
+    readonly providerName: "appsScript";
+    readonly accountId: string;
+    constructor({ googleAccountAddress }: {
+        googleAccountAddress: string;
+    });
+}

package/dist/identity/AppsScriptIdentity.js

@@ -0,0 +1,8 @@
+import { authPattern } from "../AuthPattern";
+export class AppsScriptIdentity {
+    providerName = authPattern.appsScript;
+    accountId;
+    constructor({ googleAccountAddress }) {
+        this.accountId = googleAccountAddress;
+    }
+}

package/dist/identity/EmailPasswordIdentity.d.ts

@@ -0,0 +1,13 @@
+import type { HashedPassword, Password } from "../domain/Password";
+import type { ProviderIdentity } from "./ProviderIdentity";
+export declare class EmailPasswordIdentity implements ProviderIdentity {
+    readonly providerName: "emailPassword";
+    readonly accountId: string;
+    readonly password: HashedPassword;
+    constructor({ accountId, password, }: {
+        accountId: string;
+        password: HashedPassword;
+    });
+    verify(password: Password, salt: string): Promise<boolean>;
+    changePassword(newPassword: HashedPassword): EmailPasswordIdentity;
+}

package/dist/identity/EmailPasswordIdentity.js

@@ -0,0 +1,19 @@
+import { authPattern } from "../AuthPattern";
+export class EmailPasswordIdentity {
+    providerName = authPattern.emailPassword;
+    accountId;
+    password;
+    constructor({ accountId, password, }) {
+        this.accountId = accountId;
+        this.password = password;
+    }
+    async verify(password, salt) {
+        return this.password.verify(password, salt);
+    }
+    changePassword(newPassword) {
+        return new EmailPasswordIdentity({
+            accountId: this.accountId,
+            password: newPassword,
+        });
+    }
+}

package/dist/identity/ProviderIdentity.d.ts

@@ -0,0 +1,5 @@
+import type { AuthPattern } from "../AuthPattern";
+export interface ProviderIdentity {
+    readonly providerName: AuthPattern;
+    readonly accountId: string;
+}

package/dist/identity/ProviderIdentity.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { AppsScriptAuth } from "./AppsScriptAuth";
+export type { AppsScriptAuthRepository } from "./storage/AppsScriptAuthRepository";
+export { AuthSchemaConfig, type AuthSchema, type AuthSchemaOptions, } from "./schema/AuthSchema";
+export { authPattern, type AuthPattern } from "./AuthPattern";
+export { Account } from "./domain/Account";
+export { User } from "./domain/User";
+export { HashedPassword, Password } from "./domain/Password";
+export { PasswordCredential } from "./domain/PasswordCredential";
+export { PasswordReset } from "./domain/PasswordReset";
+export { AppsScriptIdentity } from "./identity/AppsScriptIdentity";
+export { EmailPasswordIdentity } from "./identity/EmailPasswordIdentity";

package/dist/index.js

@@ -0,0 +1,10 @@
+export { AppsScriptAuth } from "./AppsScriptAuth";
+export { AuthSchemaConfig, } from "./schema/AuthSchema";
+export { authPattern } from "./AuthPattern";
+export { Account } from "./domain/Account";
+export { User } from "./domain/User";
+export { HashedPassword, Password } from "./domain/Password";
+export { PasswordCredential } from "./domain/PasswordCredential";
+export { PasswordReset } from "./domain/PasswordReset";
+export { AppsScriptIdentity } from "./identity/AppsScriptIdentity";
+export { EmailPasswordIdentity } from "./identity/EmailPasswordIdentity";

package/dist/registration/AppsScriptRegistration.d.ts

@@ -0,0 +1,13 @@
+import { User } from "../domain/User";
+import type { AppsScriptAuthRepository } from "../storage/AppsScriptAuthRepository";
+import type { Registration } from "./Registration";
+export interface AppsScriptRegistrationInput {
+    readonly name: string;
+}
+export declare class AppsScriptRegistration implements Registration<AppsScriptRegistrationInput> {
+    private readonly utilities;
+    private readonly session;
+    private readonly repository;
+    constructor(utilities: GoogleAppsScript.Utilities.Utilities, session: GoogleAppsScript.Base.Session, repository: AppsScriptAuthRepository);
+    register(input: AppsScriptRegistrationInput): Promise<User>;
+}

package/dist/registration/AppsScriptRegistration.js

@@ -0,0 +1,46 @@
+import { authPattern } from "../AuthPattern";
+import { Account } from "../domain/Account";
+import { User } from "../domain/User";
+import { AppsScriptIdentity } from "../identity/AppsScriptIdentity";
+export class AppsScriptRegistration {
+    utilities;
+    session;
+    repository;
+    constructor(utilities, session, repository) {
+        this.utilities = utilities;
+        this.session = session;
+        this.repository = repository;
+    }
+    async register(input) {
+        // Session.getActiveUser() から識別子取得
+        const email = this.session.getActiveUser().getEmail();
+        if (!email) {
+            throw new Error("No active user found");
+        }
+        const existingAccount = await this.repository.account.findByIdentity(authPattern.appsScript, email);
+        if (existingAccount) {
+            throw new Error("Account already registered");
+        }
+        // AppsScriptIdentity作成
+        const appsScriptIdentity = new AppsScriptIdentity({
+            googleAccountAddress: email,
+        });
+        const userId = this.utilities.getUuid();
+        // Account作成
+        const account = new Account({
+            id: this.utilities.getUuid(),
+            userId: userId,
+            identity: appsScriptIdentity,
+        });
+        // User作成
+        const user = new User({
+            id: userId,
+            name: input.name,
+            accounts: [account],
+        });
+        // 永続化
+        await this.repository.user.create(user);
+        // User返却
+        return user;
+    }
+}

package/dist/registration/EmailPasswordRegistration.d.ts

@@ -0,0 +1,16 @@
+import type { EmailPasswordAuthConfig } from "../authentication/EmailPasswordAuthentication";
+import { User } from "../domain/User";
+import type { AppsScriptAuthRepository } from "../storage/AppsScriptAuthRepository";
+import type { Registration } from "./Registration";
+export interface EmailPasswordRegistrationInput {
+    readonly name: string;
+    readonly email: string;
+    readonly password: string;
+}
+export declare class EmailPasswordRegistration implements Registration<EmailPasswordRegistrationInput> {
+    private readonly repository;
+    private readonly utilities;
+    private readonly config;
+    constructor(repository: AppsScriptAuthRepository, utilities: GoogleAppsScript.Utilities.Utilities, config: EmailPasswordAuthConfig);
+    register(input: EmailPasswordRegistrationInput): Promise<User>;
+}

package/dist/registration/EmailPasswordRegistration.js

@@ -0,0 +1,41 @@
+import { authPattern } from "../AuthPattern";
+import { Account } from "../domain/Account";
+import { Password } from "../domain/Password";
+import { User } from "../domain/User";
+import { EmailPasswordIdentity } from "../identity/EmailPasswordIdentity";
+export class EmailPasswordRegistration {
+    repository;
+    utilities;
+    config;
+    constructor(repository, utilities, config) {
+        this.repository = repository;
+        this.utilities = utilities;
+        this.config = config;
+    }
+    async register(input) {
+        const existingAccount = await this.repository.account.findByIdentity(authPattern.emailPassword, input.email);
+        if (existingAccount) {
+            throw new Error("Account already registered");
+        }
+        const userId = this.utilities.getUuid();
+        const accountId = this.utilities.getUuid();
+        const password = new Password(input.password, this.utilities, this.config.pepper, this.config.iterations);
+        const hashedPassword = await password.hash(accountId);
+        const identity = new EmailPasswordIdentity({
+            accountId: input.email,
+            password: hashedPassword,
+        });
+        const account = new Account({
+            id: accountId,
+            userId,
+            identity,
+        });
+        const user = new User({
+            id: userId,
+            name: input.name,
+            accounts: [account],
+        });
+        await this.repository.user.create(user);
+        return user;
+    }
+}

package/dist/registration/Registration.d.ts

@@ -0,0 +1,4 @@
+import { User } from "../domain/User";
+export interface Registration<T> {
+    register(input: T): Promise<User>;
+}

package/dist/registration/Registration.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/AuthSchema.d.ts

@@ -0,0 +1,64 @@
+export type AuthSchemaOptions = {
+    dbId: string;
+    user?: {
+        modelName?: string;
+        fields?: {
+            id?: string;
+            name?: string;
+        };
+    };
+    account?: {
+        modelName?: string;
+        fields?: {
+            id?: string;
+            userId?: string;
+            provider?: string;
+            providerAccountId?: string;
+            passwordHash?: string;
+        };
+    };
+    passwordReset?: {
+        modelName?: string;
+        fields?: {
+            id?: string;
+            accountId?: string;
+            tokenHash?: string;
+            expiresAt?: string;
+            enabled?: string;
+        };
+    };
+};
+export type AuthSchema = {
+    dbId: string;
+    user: {
+        modelName: string;
+        fields: {
+            id: string;
+            name: string;
+        };
+    };
+    account: {
+        modelName: string;
+        fields: {
+            id: string;
+            userId: string;
+            provider: string;
+            providerAccountId: string;
+            passwordHash: string;
+        };
+    };
+    passwordReset: {
+        modelName: string;
+        fields: {
+            id: string;
+            accountId: string;
+            tokenHash: string;
+            expiresAt: string;
+            enabled: string;
+        };
+    };
+};
+export declare class AuthSchemaConfig {
+    readonly schema: AuthSchema;
+    constructor(options?: AuthSchemaOptions);
+}

package/dist/schema/AuthSchema.js

@@ -0,0 +1,35 @@
+export class AuthSchemaConfig {
+    schema;
+    constructor(options = { dbId: "" }) {
+        this.schema = {
+            dbId: options.dbId,
+            user: {
+                modelName: options.user?.modelName ?? "user",
+                fields: {
+                    id: options.user?.fields?.id ?? "id",
+                    name: options.user?.fields?.name ?? "name",
+                },
+            },
+            account: {
+                modelName: options.account?.modelName ?? "account",
+                fields: {
+                    id: options.account?.fields?.id ?? "id",
+                    userId: options.account?.fields?.userId ?? "userId",
+                    provider: options.account?.fields?.provider ?? "provider",
+                    providerAccountId: options.account?.fields?.providerAccountId ?? "providerAccountId",
+                    passwordHash: options.account?.fields?.passwordHash ?? "passwordHash",
+                },
+            },
+            passwordReset: {
+                modelName: options.passwordReset?.modelName ?? "passwordReset",
+                fields: {
+                    id: options.passwordReset?.fields?.id ?? "id",
+                    accountId: options.passwordReset?.fields?.accountId ?? "accountId",
+                    tokenHash: options.passwordReset?.fields?.tokenHash ?? "tokenHash",
+                    expiresAt: options.passwordReset?.fields?.expiresAt ?? "expiresAt",
+                    enabled: options.passwordReset?.fields?.enabled ?? "enabled",
+                },
+            },
+        };
+    }
+}

package/dist/storage/AppsScriptAuthRepository.d.ts

@@ -0,0 +1,17 @@
+import type { AuthPattern } from "../AuthPattern";
+import { Account } from "../domain/Account";
+import type { PasswordCredential } from "../domain/PasswordCredential";
+import type { User } from "../domain/User";
+export interface AppsScriptAuthRepository {
+    account: {
+        findByIdentity(provider: AuthPattern, identifier: string): Promise<Account | null>;
+    };
+    user: {
+        find: (id: string) => Promise<User | null>;
+        create: (user: User) => Promise<User>;
+    };
+    passwordCredential: {
+        findByResetTokenHash(tokenHash: string): Promise<PasswordCredential | null>;
+        save(credential: PasswordCredential): Promise<void>;
+    };
+}

package/dist/storage/AppsScriptAuthRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/storage/AppsScriptCacheSessionStorage.d.ts

@@ -0,0 +1,10 @@
+import { Session, type SessionId } from "../domain/Session";
+import type { AppsScriptSessionStorage } from "./AppsScriptSessionStorage";
+export declare class AppsScriptCacheSessionStorage implements AppsScriptSessionStorage {
+    private readonly storage;
+    constructor(storage: GoogleAppsScript.Cache.Cache);
+    save(session: Session): Promise<void>;
+    get(id: SessionId): Promise<Session | null>;
+    delete(id: SessionId): Promise<void>;
+    cleanupExpired(): Promise<void>;
+}

package/dist/storage/AppsScriptCacheSessionStorage.js

@@ -0,0 +1,30 @@
+import { Session } from "../domain/Session";
+export class AppsScriptCacheSessionStorage {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async save(session) {
+        const expirationInSeconds = Math.floor((session.expiresAt.getTime() - Date.now()) / 1000);
+        this.storage.put(session.id, JSON.stringify(session), expirationInSeconds);
+    }
+    async get(id) {
+        const value = this.storage.get(id);
+        if (!value) {
+            return null;
+        }
+        const data = JSON.parse(value);
+        return new Session({
+            id: data.id,
+            userId: data.userId,
+            createdAt: new Date(data.createdAt),
+            expiresAt: new Date(data.expiresAt),
+        });
+    }
+    async delete(id) {
+        this.storage.remove(id);
+    }
+    async cleanupExpired() {
+        // CacheService handles expiration automatically.
+    }
+}

package/dist/storage/AppsScriptPropertiesSessionStorage.d.ts

@@ -0,0 +1,11 @@
+import { Session, SessionId } from "../domain/Session";
+import type { AppsScriptSessionStorage } from "./AppsScriptSessionStorage";
+export declare class AppsScriptPropertiesSessionStorage implements AppsScriptSessionStorage {
+    private readonly storage;
+    private readonly prefix;
+    constructor(storage: GoogleAppsScript.Properties.Properties);
+    save(session: Session): Promise<void>;
+    get(id: SessionId): Promise<Session | null>;
+    delete(id: SessionId): Promise<void>;
+    cleanupExpired(): Promise<void>;
+}

package/dist/storage/AppsScriptPropertiesSessionStorage.js

@@ -0,0 +1,51 @@
+import { Session } from "../domain/Session";
+export class AppsScriptPropertiesSessionStorage {
+    storage;
+    prefix = "session:";
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async save(session) {
+        this.storage.setProperty(`${this.prefix}${session.id}`, JSON.stringify(session));
+    }
+    async get(id) {
+        const value = this.storage.getProperty(`${this.prefix}${id}`);
+        if (!value) {
+            return null;
+        }
+        const stored = JSON.parse(value);
+        const session = new Session({
+            id: stored.id,
+            userId: stored.userId,
+            createdAt: new Date(stored.createdAt),
+            expiresAt: new Date(stored.expiresAt),
+        });
+        if (session.expiresAt.getTime() <= Date.now()) {
+            this.storage.deleteProperty(`${this.prefix}${id}`);
+            return null;
+        }
+        return session;
+    }
+    async delete(id) {
+        this.storage.deleteProperty(`${this.prefix}${id}`);
+    }
+    async cleanupExpired() {
+        const properties = this.storage.getProperties();
+        const now = new Date();
+        for (const [key, value] of Object.entries(properties)) {
+            if (!key.startsWith(this.prefix)) {
+                continue;
+            }
+            const sessionData = JSON.parse(value);
+            const session = new Session({
+                id: sessionData.id,
+                userId: sessionData.userId,
+                createdAt: new Date(sessionData.createdAt),
+                expiresAt: new Date(sessionData.expiresAt),
+            });
+            if (session.isExpired(now)) {
+                this.storage.deleteProperty(key);
+            }
+        }
+    }
+}

package/dist/storage/AppsScriptSessionStorage.d.ts

@@ -0,0 +1,7 @@
+import type { Session, SessionId } from "../domain/Session";
+export interface AppsScriptSessionStorage {
+    save(session: Session): Promise<void>;
+    get(id: SessionId): Promise<Session | null>;
+    delete(id: SessionId): Promise<void>;
+    cleanupExpired(): Promise<void>;
+}

package/dist/storage/AppsScriptSessionStorage.js

@@ -0,0 +1 @@
+export {};