Gatsbyで作成したブログにコメント機能をつけてみた

import * as React from 'react';
import Image from './Image';

interface Props {
  slug: string;
}

const base_url = 'https://accounts.google.com/o/oauth2/auth';
const clientId = 'your_client_id';
const redirect_uri = encodeURIComponent('https://www.example.com/path/to/callback');
const scope = 'profile email';

const GoogleAuth: React.FC<Props> = ({slug}) => {
  const href = `${base_url}?client_id=${clientId}&redirect_uri=${redirect_uri}&scope=${scope}&response_type=code&state=${slug}`;

  const onClick = React.useCallback(() => {
    window.location.assign(href);
  }, []);

  return (
    <button className={'button is-link'} onClick={onClick}>
      <span className={'icon'}>
        <Image fileName={'google.png'} alt={'google'} />
      </span>
      <span>Sign Up With Google</span>
    </button>
  );
};

export default GoogleAuth;

user_repository = UserRepository()
refresh_token_repository = RefreshTokenRepository()

@app.route('/path/to/callback')
def get_handler():
    try:
        code = request.args.get('code', None)
        state = request.args.get('state', '/')
        if code is None:
            raise Exception('code is None')

        # google oauth apiからaccess tokenを取得する。
        # id tokenの署名もチェックする。
        access_token = google_auth_utils.get_access_token(code)
        if access_token is None:
            raise Exception('failed to get access token')

        # google oauth apiからuser infoを取得する。
        user_info = google_auth_utils.get_user_info(access_token)
        if user_info is None:
            raise Exception('failed to get user info')

        name = user_info.get('name', None)
        email = user_info.get('email', None)
        if name is None or email is None:
            raise Exception('name or email is invalid')

        # すでにemailが登録されているかどうか確認し、登録されていなければ新しく作成する。
        user = user_repository.get_user(email=email)
        if user is None:
            user = user_repository.create_user(email=email, name=name)

        if user is None:
            raise Exception('failed to create user')

        # refresh_tokenを新しく作成する。
        refresh_token = refresh_token_repository.publish_token(user_id=user['id'])
        if refresh_token is None:
            raise Exception('failed to publish refresh token')

        # refresh_tokenをcookieとして設定し、ユーザーが元いたページにredirectする。
        res = redirect(location="http://www.takigawa-memo.com{}".format(state))
        max_age = refresh_token_repository.ttl
        res.set_cookie('refresh_token', value=refresh_token, max_age=max_age, path="/login", httponly=True,
                       secure=True, samesite="Lax")
        return res

    except Exception as e:
        print(e)
        print(traceback.format_exc())
        return get_error_response("failed to handle google auth redirect")

# https://github.com/ibejohn818/flask-dynamodb-sessions

class Session(object):

    def __init__(self, app=None):
        if app is None:
            raise Exception('app is None')

        table_name = os.getenv('SessionIdTableName', 'sessionId')
        ttl_seconds = 60 * 30

        kw = {
            'table': table_name,
            'ttl': ttl_seconds,
        }

        interface = DynamodbSessionInterface(**kw)

        app.session_interface = interface


class DynamodbSessionInterface(SessionInterface):
    """
    """
    _boto_client = None

    def __init__(self, **kw):
        self.table = kw.get('table', 'sessionId')
        self.ttl = kw.get('ttl', None)

    def open_session(self, app, req):
        """
        """
        print("open_session called")
        sid = req.cookies.get(app.session_cookie_name)

        # まだsession idが発行されていない。
        if sid is None:
            sid = secrets.token_urlsafe(32)
            return DynamodbSession(sid=sid)

        item = self.dynamo_get(sid)

        # DB上にsession idに紐づくデータが保存されてない。
        if not item:
            return DynamodbSession(sid=sid)

        # session idの期限切れ
        print(item)
        now = int(datetime.utcnow().timestamp())
        ttl = int(item.get('ttl'))
        if ttl < now:
            self.delete_session(session_id=sid)
            sid = secrets.token_urlsafe(32)
            return DynamodbSession(sid=sid)

        data = self.hydrate_session(item.get('data'))

        return DynamodbSession(data, sid=sid)

    def save_session(self, app, session, res):
        """
        """
        print("save_session called")
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)

        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        expires = self.get_expiration_time(app, session)
        session_id = session.sid

        # sessionのdataに格納されているユーザー情報が変更された
        if session.modified:
            self.dynamo_save(session_id, dict(session))

        res.set_cookie(app.session_cookie_name, session_id,
                       expires=expires, httponly=httponly,
                       domain=domain, path=path, secure=secure)

    def pickle_session(self, session):
        """Pickle the session object and base64 encode it
            for storage as a dynamo string
        """
        pickled = pickle.dumps(session)

        canned = codecs.encode(pickled, 'base64').decode()

        return canned

    def hydrate_session(self, session_data):
        """Base64 decode string back to bytes and unpickle
        """
        uncanned = codecs.decode(session_data.encode(), 'base64')

        pickled = pickle.loads(uncanned)

        return pickled

    def dynamo_get(self, session_id):
        """
        """
        try:
            res = self.session_id_table().get_item(Key={'id': session_id})
            return res.get('Item')
        except Exception as e:
            print("DYNAMO SESSION GET ITEM ERR: ", str(e))

        return None

    def dynamo_save(self, session_id, session):
        try:
            fields = {
                'data': self.pickle_session(session),
                'modified': str(datetime.utcnow()),
                'ttl': str(int(datetime.utcnow().timestamp() + self.ttl))
            }
            print('dynamo save', fields)

            attr_names = {}
            attr_vals = {}
            ud_exp = []
            for k, v in fields.items():
                attr = "#attr_{}".format(k)
                token = ":{}".format(k)
                ud_exp.append("{} = {}".format(attr, token))
                attr_names[attr] = k
                attr_vals[token] = v

            self.session_id_table().update_item(Key={'id': session_id},
                                                ExpressionAttributeNames=attr_names,
                                                ExpressionAttributeValues=attr_vals,
                                                UpdateExpression="SET {}".format(", ".join(ud_exp)),
                                                ReturnValues='NONE')
        except Exception as e:
            print("DYNAMO SESSION SAVE ERR: ", str(e))

    def delete_session(self, session_id):
        try:
            print("delete session id", session_id)
            self.session_id_table().delete_item(Key={'id': session_id})
        except Exception as e:
            print("DYNAMO SESSION DELETE ERR: ", str(e))

    def session_id_table(self):
        if self._boto_client is None:
            self._boto_client = boto3.resource('dynamodb')

        return self._boto_client.Table(self.table)

app = Flask(__name__)
Session(app)

user_repository = UserRepository()
refresh_token_repository = RefreshTokenRepository()


@app.route('/login')
def get_handler():
    try:
        refresh_token = request.cookies.get('refresh_token', None)
        if refresh_token is None:
            return get_unauthorized_response("refresh token is null")

        user_id = refresh_token_repository.get_user_id(refresh_token)
        if user_id is None:
            return get_unauthorized_response('invalid refresh token')

        session['user_id'] = user_id

        user = user_repository.get_user(user_id=user_id)
        if user is None:
            raise Exception('failed to get user. user_id={}'.format(user_id))

        return {"user": user}

    except Exception as e:
        print(e)
        print(traceback.format_exc())
        return get_error_response()

{
  "TableName": "userId",
  "AttributeDefinitions": [
    {
      "AttributeName": "id",
      "AttributeType": "N"
    }
  ],
  "KeySchema": [
    {
      "AttributeName": "id",
      "KeyType": "HASH"
    }
  ],
  "ProvisionedThroughput": {
    "ReadCapacityUnits": 1,
    "WriteCapacityUnits": 1
  }
}

class IdGenerator:
    def __init__(self, sequence_table):
        self.sequence_table = sequence_table

    def next_id(self) -> int:
        res = self.sequence_table.update_item(
            Key={'id': 0},
            UpdateExpression="ADD #name :increment",
            ExpressionAttributeNames={
                '#name': 'sequence'
            },
            ExpressionAttributeValues={
                ":increment": int(1)
            },
            ReturnValues="UPDATED_NEW"
        )

        return res['Attributes']['sequence']

  SessionIdTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      ProvisionedThroughput:
        ReadCapacityUnits: 2
        WriteCapacityUnits: 2
      TimeToLiveSpecification:
        AttributeName: ttl
        Enabled: true