com.backnd.database 0.0.1

package/Tools/BTask.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3d21f87f626064f58a45e4841d3be881
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tools/DatabaseLoop.cs

@@ -0,0 +1,110 @@
+using System;
+
+using UnityEngine;
+using UnityEngine.LowLevel;
+using UnityEngine.PlayerLoop;
+
+namespace BACKND.Database
+{
+    public static class DatabaseLoop
+    {
+        internal enum AddMode { Beginning, End }
+
+        public static Action OnEarlyUpdate;
+        public static Action OnLateUpdate;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void ResetStatics()
+        {
+            OnEarlyUpdate = null;
+            OnLateUpdate = null;
+        }
+
+        internal static int FindPlayerLoopEntryIndex(PlayerLoopSystem.UpdateFunction function, PlayerLoopSystem playerLoop, Type playerLoopSystemType)
+        {
+            if (playerLoop.type == playerLoopSystemType)
+                return Array.FindIndex(playerLoop.subSystemList, (elem => elem.updateDelegate == function));
+
+            if (playerLoop.subSystemList != null)
+            {
+                for (int i = 0; i < playerLoop.subSystemList.Length; ++i)
+                {
+                    int index = FindPlayerLoopEntryIndex(function, playerLoop.subSystemList[i], playerLoopSystemType);
+                    if (index != -1) return index;
+                }
+            }
+            return -1;
+        }
+
+        internal static bool AddToPlayerLoop(PlayerLoopSystem.UpdateFunction function, Type ownerType, ref PlayerLoopSystem playerLoop, Type playerLoopSystemType, AddMode addMode)
+        {
+            if (playerLoop.type == playerLoopSystemType)
+            {
+                if (Array.FindIndex(playerLoop.subSystemList, (s => s.updateDelegate == function)) != -1)
+                {
+                    return true;
+                }
+
+                int oldListLength = (playerLoop.subSystemList != null) ? playerLoop.subSystemList.Length : 0;
+                Array.Resize(ref playerLoop.subSystemList, oldListLength + 1);
+
+                PlayerLoopSystem system = new PlayerLoopSystem
+                {
+                    type = ownerType,
+                    updateDelegate = function
+                };
+
+                if (addMode == AddMode.Beginning)
+                {
+                    Array.Copy(playerLoop.subSystemList, 0, playerLoop.subSystemList, 1, playerLoop.subSystemList.Length - 1);
+                    playerLoop.subSystemList[0] = system;
+                }
+                else if (addMode == AddMode.End)
+                {
+                    playerLoop.subSystemList[oldListLength] = system;
+                }
+
+                return true;
+            }
+
+            if (playerLoop.subSystemList != null)
+            {
+                for (int i = 0; i < playerLoop.subSystemList.Length; ++i)
+                {
+                    if (AddToPlayerLoop(function, ownerType, ref playerLoop.subSystemList[i], playerLoopSystemType, addMode))
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void RuntimeInitializeOnLoad()
+        {
+            PlayerLoopSystem playerLoop = PlayerLoop.GetCurrentPlayerLoop();
+
+            bool earlyAdded = AddToPlayerLoop(DatabaseEarlyUpdate, typeof(DatabaseLoop), ref playerLoop, typeof(EarlyUpdate), AddMode.End);
+            bool lateAdded = AddToPlayerLoop(DatabaseLateUpdate, typeof(DatabaseLoop), ref playerLoop, typeof(PreLateUpdate), AddMode.End);
+
+            PlayerLoop.SetPlayerLoop(playerLoop);
+
+        }
+
+        static void DatabaseEarlyUpdate()
+        {
+            if (!Application.isPlaying) return;
+
+            OnEarlyUpdate?.Invoke();
+        }
+
+        static void DatabaseLateUpdate()
+        {
+            if (!Application.isPlaying) return;
+
+            if (OnLateUpdate != null)
+            {
+                OnLateUpdate.Invoke();
+            }
+        }
+    }
+}

package/Tools/DatabaseLoop.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 18e80028fcc974189aeef46732102b2c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tools/JsonHelper.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Globalization;
+
+using Newtonsoft.Json;
+
+namespace BACKND.Database
+{
+    /// <summary>
+    /// JSON serialization helper for database operations
+    /// </summary>
+    public static class JsonHelper
+    {
+        /// <summary>
+        /// Deserialize object from JSON string to target type
+        /// </summary>
+        /// <typeparam name="T">Target type</typeparam>
+        /// <param name="value">Input object (string or other)</param>
+        /// <returns>Deserialized object of type T</returns>
+        public static T DeserializeObject<T>(object value)
+        {
+            if (value == null)
+                return default(T);
+
+            // If the value is already the correct type, return it directly
+            if (value is T directValue)
+                return directValue;
+
+            // Convert to string and deserialize
+            string jsonString = value.ToString();
+
+            try
+            {
+                return JsonConvert.DeserializeObject<T>(jsonString);
+            }
+            catch (Exception ex)
+            {
+                UnityEngine.Debug.LogWarning($"Failed to deserialize JSON for type {typeof(T).Name}: {ex.Message}");
+                return default(T);
+            }
+        }
+
+        /// <summary>
+        /// Serialize object to JSON string
+        /// </summary>
+        /// <param name="value">Object to serialize</param>
+        /// <returns>JSON string</returns>
+        public static string SerializeObject(object value)
+        {
+            if (value == null)
+                return null;
+
+            try
+            {
+                return JsonConvert.SerializeObject(value);
+            }
+            catch (Exception ex)
+            {
+                UnityEngine.Debug.LogWarning($"Failed to serialize object to JSON: {ex.Message}");
+                return value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Convert object to string, preserving ISO 8601 format for DateTime
+        /// </summary>
+        /// <param name="value">Input object</param>
+        /// <returns>String representation</returns>
+        public static string ConvertToString(object value)
+        {
+            if (value == null)
+                return null;
+
+            if (value is string strValue)
+                return strValue;
+
+            if (value is DateTime dateValue)
+                return dateValue.ToString("yyyy-MM-ddTHH:mm:ss.fffZ", CultureInfo.InvariantCulture);
+
+            return value.ToString();
+        }
+    }
+}

package/Tools/JsonHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b15410c5d076458e962881b7285b8ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tools.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4ac9fdc25ea1e46a7896049e7636c264
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/TransactionBuilder.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using BACKND.Database.Network;
+
+using Newtonsoft.Json;
+
+namespace BACKND.Database
+{
+    /// <summary>
+    /// 트랜잭션 빌더 - 여러 데이터베이스 작업을 원자적으로 실행
+    /// </summary>
+    public class TransactionBuilder
+    {
+        private readonly Client client;
+        private readonly List<string> statements = new();
+
+        /// <summary>
+        /// 현재 활성화된 TransactionQueryBuilder (암묵적 실행용)
+        /// </summary>
+        internal TransactionQueryBuilderBase activeQueryBuilder;
+
+        internal TransactionBuilder(Client client)
+        {
+            this.client = client;
+        }
+
+        /// <summary>
+        /// 특정 모델 타입에 대한 쿼리 빌더 시작
+        /// </summary>
+        public TransactionQueryBuilder<T> From<T>() where T : BaseModel, new()
+        {
+            // 이전에 활성화된 QueryBuilder가 있고 미완료 작업이 있으면 flush
+            FlushActiveQueryBuilder();
+
+            var queryBuilder = new TransactionQueryBuilder<T>(this, client);
+            activeQueryBuilder = queryBuilder;
+            return queryBuilder;
+        }
+
+        /// <summary>
+        /// 활성화된 QueryBuilder의 미완료 작업을 flush
+        /// </summary>
+        internal void FlushActiveQueryBuilder()
+        {
+            if (activeQueryBuilder != null && activeQueryBuilder.HasPendingSetClauses)
+            {
+                activeQueryBuilder.FlushPendingSetClauses();
+            }
+            activeQueryBuilder = null;
+        }
+
+        /// <summary>
+        /// SQL 문장 추가 (내부용)
+        /// </summary>
+        internal void AddStatement(string sql)
+        {
+            if (string.IsNullOrWhiteSpace(sql))
+                throw new ArgumentException("SQL statement cannot be empty");
+
+            statements.Add(sql);
+        }
+
+        /// <summary>
+        /// 현재 트랜잭션에 포함된 작업 수
+        /// </summary>
+        public int Count => statements.Count;
+
+        /// <summary>
+        /// 트랜잭션 실행
+        /// </summary>
+        public async BTask<TransactionResult> CommitAsync()
+        {
+            // 미완료 작업이 있으면 flush
+            FlushActiveQueryBuilder();
+
+            if (statements.Count == 0)
+                throw new InvalidOperationException("Transaction has no operations. Add at least one operation before committing.");
+
+            // DynamoDB TransactWriteItems 제한: 100개
+            const int maxOperations = 100;
+            if (statements.Count > maxOperations)
+                throw new InvalidOperationException($"Transaction exceeds maximum operations limit. Maximum: {maxOperations}, Current: {statements.Count}");
+
+            // 트랜잭션 SQL 생성
+            var sb = new StringBuilder();
+            sb.AppendLine("BEGIN;");
+            foreach (var statement in statements)
+            {
+                sb.Append(statement);
+                if (!statement.EndsWith(";"))
+                    sb.Append(";");
+                sb.AppendLine();
+            }
+            sb.Append("COMMIT;");
+
+            var request = new DatabaseRequest
+            {
+                Query = sb.ToString(),
+                Parameters = new Dictionary<string, object>()
+            };
+
+            // user_uuid 파라미터 추가
+            if (client.UserUUID != null)
+            {
+                request.Parameters["@current_user_uuid"] = client.UserUUID;
+            }
+
+            var response = await client.ExecuteTransaction(request);
+
+            if (!response.Success)
+            {
+                return new TransactionResult
+                {
+                    Success = false,
+                    OperationCount = statements.Count,
+                    Error = response.Error,
+                    Message = "Transaction failed"
+                };
+            }
+
+            // 결과 파싱 시도
+            TransactionResult result;
+            try
+            {
+                result = JsonConvert.DeserializeObject<TransactionResult>(response.Result);
+                if (result == null)
+                {
+                    result = new TransactionResult();
+                }
+            }
+            catch
+            {
+                result = new TransactionResult();
+            }
+
+            result.Success = true;
+            result.OperationCount = statements.Count;
+            result.Message = result.Message ?? "Transaction committed successfully";
+
+            return result;
+        }
+    }
+
+    /// <summary>
+    /// TransactionQueryBuilder 베이스 클래스 (암묵적 실행 지원용)
+    /// </summary>
+    public abstract class TransactionQueryBuilderBase
+    {
+        internal abstract bool HasPendingSetClauses { get; }
+        internal abstract void FlushPendingSetClauses();
+    }
+}

package/TransactionBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 15c18476cba204c66a8910780b6c3bf8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/TransactionQueryBuilder.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+using BACKND.Database.Internal;
+
+namespace BACKND.Database
+{
+    /// <summary>
+    /// 트랜잭션용 쿼리 빌더
+    /// </summary>
+    public class TransactionQueryBuilder<T> : TransactionQueryBuilderBase where T : BaseModel, new()
+    {
+        private readonly TransactionBuilder transaction;
+        private readonly Client client;
+        private readonly T modelInstance;
+        private readonly ExpressionAnalyzer expressionAnalyzer;
+
+        private readonly List<WhereCondition> whereConditions = new();
+        private readonly List<SetClause> setClauses = new();
+        private bool isOfCurrentUser;
+
+        internal TransactionQueryBuilder(TransactionBuilder transaction, Client client)
+        {
+            this.transaction = transaction;
+            this.client = client;
+            this.modelInstance = new T();
+            this.expressionAnalyzer = new ExpressionAnalyzer(modelInstance);
+        }
+
+        internal override bool HasPendingSetClauses => setClauses.Count > 0;
+
+        internal override void FlushPendingSetClauses()
+        {
+            if (setClauses.Count == 0)
+                return;
+
+            if (whereConditions.Count == 0)
+                throw new InvalidOperationException("Inc/Dec requires a WHERE clause");
+
+            var whereClause = SqlBuilder.BuildWhereClause(
+                whereConditions,
+                isOfCurrentUser,
+                modelInstance.GetTableType());
+            var sql = SqlBuilder.BuildUpdateQueryFromSetClauses(
+                modelInstance.GetTableName(),
+                setClauses,
+                whereClause);
+
+            transaction.AddStatement(sql);
+            setClauses.Clear();
+        }
+
+        #region 조건 빌더 (체이닝 → 자신 반환)
+
+        /// <summary>
+        /// WHERE 조건 추가
+        /// </summary>
+        public TransactionQueryBuilder<T> Where(Expression<Func<T, bool>> predicate)
+        {
+            var condition = expressionAnalyzer.AnalyzeSingle(predicate, whereConditions);
+            if (condition != null)
+            {
+                whereConditions.Add(condition);
+            }
+            return this;
+        }
+
+        /// <summary>
+        /// 현재 사용자 데이터만 대상 (UserTable용)
+        /// </summary>
+        public TransactionQueryBuilder<T> OfCurrentUser()
+        {
+            isOfCurrentUser = true;
+            return this;
+        }
+
+        /// <summary>
+        /// 필드 값 증가
+        /// </summary>
+        public TransactionQueryBuilder<T> Inc<TField>(Expression<Func<T, TField>> selector, TField value)
+        {
+            var columnName = expressionAnalyzer.GetColumnNameFromKeySelector(selector);
+            ValidateNoDuplicateSetClause(columnName);
+            setClauses.Add(new SetClause
+            {
+                ColumnName = columnName,
+                Operator = "+",
+                Value = value
+            });
+            return this;
+        }
+
+        /// <summary>
+        /// 필드 값 감소
+        /// </summary>
+        public TransactionQueryBuilder<T> Dec<TField>(Expression<Func<T, TField>> selector, TField value)
+        {
+            var columnName = expressionAnalyzer.GetColumnNameFromKeySelector(selector);
+            ValidateNoDuplicateSetClause(columnName);
+            setClauses.Add(new SetClause
+            {
+                ColumnName = columnName,
+                Operator = "-",
+                Value = value
+            });
+            return this;
+        }
+
+        private void ValidateNoDuplicateSetClause(string columnName)
+        {
+            if (setClauses.Any(c => c.ColumnName == columnName))
+                throw new InvalidOperationException($"'{columnName}' is already being modified. Each field can only be modified once.");
+        }
+
+        #endregion
+
+        #region 실행 메서드 (SQL 추가 → TransactionBuilder 반환)
+
+        /// <summary>
+        /// INSERT 작업 추가
+        /// </summary>
+        public TransactionBuilder Insert(T model)
+        {
+            if (model == null)
+                throw new ArgumentNullException(nameof(model));
+
+            var sql = SqlBuilder.BuildInsertQuery(model, out _);
+            transaction.AddStatement(sql);
+
+            // 활성 QueryBuilder 해제
+            transaction.activeQueryBuilder = null;
+            return transaction;
+        }
+
+        /// <summary>
+        /// UPDATE 작업 추가
+        /// </summary>
+        public TransactionBuilder Update(T model)
+        {
+            if (model == null)
+                throw new ArgumentNullException(nameof(model));
+
+            // WHERE 절이 없으면 PrimaryKey로 자동 생성
+            if (whereConditions.Count == 0)
+            {
+                var pkConditions = SqlBuilder.BuildPrimaryKeyConditions(model);
+                whereConditions.AddRange(pkConditions);
+            }
+
+            var whereClause = SqlBuilder.BuildWhereClause(
+                whereConditions,
+                isOfCurrentUser,
+                modelInstance.GetTableType());
+            var sql = SqlBuilder.BuildUpdateQuery(model, whereClause, out _);
+            transaction.AddStatement(sql);
+
+            // 활성 QueryBuilder 해제
+            transaction.activeQueryBuilder = null;
+            return transaction;
+        }
+
+        /// <summary>
+        /// DELETE 작업 추가
+        /// </summary>
+        public TransactionBuilder Delete()
+        {
+            if (whereConditions.Count == 0)
+                throw new InvalidOperationException("Delete requires a WHERE clause");
+
+            var whereClause = SqlBuilder.BuildWhereClause(
+                whereConditions,
+                isOfCurrentUser,
+                modelInstance.GetTableType());
+            var sql = SqlBuilder.BuildDeleteQuery(modelInstance.GetTableName(), whereClause);
+            transaction.AddStatement(sql);
+
+            // 활성 QueryBuilder 해제
+            transaction.activeQueryBuilder = null;
+            return transaction;
+        }
+
+        #endregion
+
+        #region 암묵적 실행을 위한 From<U>()
+
+        /// <summary>
+        /// 다른 테이블로 전환 (현재 Inc/Dec 작업이 있으면 자동 flush)
+        /// </summary>
+        public TransactionQueryBuilder<U> From<U>() where U : BaseModel, new()
+        {
+            // 현재 Inc/Dec 작업이 있으면 자동으로 UPDATE SQL 생성
+            if (HasPendingSetClauses)
+            {
+                FlushPendingSetClauses();
+            }
+
+            // 새 QueryBuilder 생성
+            return transaction.From<U>();
+        }
+
+        #endregion
+    }
+}

package/TransactionQueryBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2eb969df47e9149488fe15818b3937f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/TransactionResult.cs

@@ -0,0 +1,33 @@
+namespace BACKND.Database
+{
+    /// <summary>
+    /// 트랜잭션 실행 결과
+    /// </summary>
+    public class TransactionResult
+    {
+        /// <summary>
+        /// 트랜잭션 성공 여부
+        /// </summary>
+        public bool Success { get; set; }
+
+        /// <summary>
+        /// 트랜잭션에 포함된 작업 수
+        /// </summary>
+        public int OperationCount { get; set; }
+
+        /// <summary>
+        /// 결과 메시지
+        /// </summary>
+        public string Message { get; set; }
+
+        /// <summary>
+        /// 에러 메시지 (실패 시)
+        /// </summary>
+        public string Error { get; set; }
+
+        /// <summary>
+        /// 영향받은 총 행 수
+        /// </summary>
+        public int TotalAffectedRows { get; set; }
+    }
+}

package/TransactionResult.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 42d64baeef2e04aaaa813580bbf5ad1f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "com.backnd.database",
+  "version": "0.0.1",
+  "displayName": "BACKND Database",
+  "description": "BACKND Database is a Unity SDK for seamless integration with BACKND cloud database services.\n\nEasily manage and synchronize game data such as player profiles, game states, and leaderboards across multiple platforms.\nIdeal for Unity developers looking to implement robust database solutions without complex backend setups.",
+  "unity": "2021.3",
+  "keywords": [
+    "backnd",
+    "unity",
+    "database",
+    "networking"
+  ],
+  "dependencies": {},
+  "category": "SDK",
+  "author": {
+    "name": "backnd",
+    "email": "help@thebackend.io",
+    "url": "https://backnd.com"
+  }
+}