com.backnd.database 0.0.1

package/Attributes/ColumnAttribute.cs

@@ -0,0 +1,46 @@
+using System;
+
+namespace BACKND.Database
+{
+    public enum DatabaseType
+    {
+        None,
+        Int32,
+        UInt32,
+        Int64,
+        UInt64,
+        Float,
+        Bool,
+        String,
+        DateTime,
+        UUID,
+        Json
+    }
+
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    public sealed class ColumnAttribute : Attribute
+    {
+        public string ColumnName { get; } = string.Empty;
+        public DatabaseType DataType { get; } = DatabaseType.None;
+        public bool NotNull { get; set; } = false;
+        public string DefaultValue { get; set; } = string.Empty;
+
+        public ColumnAttribute() { }
+
+        public ColumnAttribute(string columnName)
+        {
+            ColumnName = columnName;
+        }
+
+        public ColumnAttribute(DatabaseType dataType)
+        {
+            DataType = dataType;
+        }
+
+        public ColumnAttribute(string columnName, DatabaseType dataType)
+        {
+            ColumnName = columnName;
+            DataType = dataType;
+        }
+    }
+}

package/Attributes/ColumnAttribute.cs.meta

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

package/Attributes/PrimaryKeyAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace BACKND.Database
+{
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    public class PrimaryKeyAttribute : Attribute
+    {
+        public bool AutoIncrement { get; set; } = false;
+
+        public PrimaryKeyAttribute() { }
+    }
+}

package/Attributes/PrimaryKeyAttribute.cs.meta

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

package/Attributes/TableAttribute.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace BACKND.Database
+{
+    public enum TableType
+    {
+        UserTable = 1,
+        FlexibleTable = 2
+    }
+
+    public enum TablePermission
+    {
+        SELF,
+        OTHERS
+    }
+
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public class TableAttribute : Attribute
+    {
+        public string TableName { get; } = string.Empty;
+        public TableType TableType { get; } = TableType.FlexibleTable;
+        public bool ClientAccess { get; set; } = true;
+        public TablePermission[] ReadPermissions { get; set; } = { TablePermission.SELF, TablePermission.OTHERS };
+        public TablePermission[] WritePermissions { get; set; } = { TablePermission.SELF, TablePermission.OTHERS };
+
+        public TableAttribute() { }
+
+        public TableAttribute(string tableName)
+        {
+            TableName = tableName;
+        }
+
+        public TableAttribute(TableType tableType)
+        {
+            TableType = tableType;
+        }
+
+        public TableAttribute(string tableName, TableType tableType)
+        {
+            TableName = tableName;
+            TableType = tableType;
+        }
+    }
+}

package/Attributes/TableAttribute.cs.meta

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

package/Attributes.meta

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

package/BACKND.Database.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "BACKND.Database",
+    "rootNamespace": "BACKND.Database",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/BACKND.Database.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cc8137176009d4057ba08d3ae1d0f9c1
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/BaseModel.cs

@@ -0,0 +1,22 @@
+namespace BACKND.Database
+{
+    public abstract class BaseModel
+    {
+        public virtual string GetTableName() { return string.Empty; }
+        public virtual TableType GetTableType() { return TableType.FlexibleTable; }
+        public virtual bool GetClientAccess() { return false; }
+        public virtual string[] GetReadPermissions() { return new string[] { "SELF", "OTHERS" }; }
+        public virtual string[] GetWritePermissions() { return new string[] { "SELF", "OTHERS" }; }
+        public virtual string[] GetPrimaryKeyColumnNames() { return new string[0]; }
+        public virtual string GetAutoIncrementColumnName() { return string.Empty; }
+        public virtual string GetPrimaryKey() { return string.Empty; }
+        public virtual string GetColumnList() { return string.Empty; }
+        public virtual string GetColumnDataType(string columnName) { return string.Empty; }
+        public virtual bool IsColumnNullable(string columnName) { return false; }
+        public virtual bool IsPropertyNullableType(string columnName) { return false; }
+        public virtual string GetColumnDefaultValue(string columnName) { return string.Empty; }
+        public virtual string GetColumnName(string propertyName) { return string.Empty; }
+        public virtual object GetValue(string columnName) { return null; }
+        public virtual void SetValue(string columnName, object value) { }
+    }
+}

package/BaseModel.cs.meta

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

package/Client.cs

@@ -0,0 +1,490 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+using BACKND.Database.Exceptions;
+using BACKND.Database.Network;
+
+namespace BACKND.Database
+{
+    public class Client
+    {
+        public string UserUUID => headers.ContainsKey("x-gamerid") ? headers["x-gamerid"] : null;
+
+        private bool initialized = false;
+
+        private readonly Dictionary<string, string> headers = new Dictionary<string, string>();
+
+        private readonly Dictionary<Type, bool> createdTables = new Dictionary<Type, bool>();
+
+        private readonly Queue<QueuedRequest> requestQueue = new Queue<QueuedRequest>();
+        private readonly Queue<QueuedRequest> highPriorityQueue = new Queue<QueuedRequest>();
+        private readonly object queueLock = new object();
+        private bool isProcessingQueue = false;
+        private readonly CancellationTokenSource queueCancellationSource;
+        private readonly float requestDelay = 0.1f;
+
+        public Client(string uuid)
+        {
+            headers["database_uuid"] = uuid;
+
+            this.queueCancellationSource = new CancellationTokenSource();
+        }
+
+        public async BTask Initialize()
+        {
+            if (initialized)
+            {
+                return;
+            }
+
+            var userInfoResult = await GetUserInfoAsync();
+            if (!userInfoResult.IsSuccess())
+            {
+                UnityEngine.Debug.LogError("Failed to Backnd Service Initialization or Login Process - " + userInfoResult.ToString());
+                return;
+            }
+
+            var json = Newtonsoft.Json.Linq.JObject.Parse(userInfoResult.ReturnValue);
+            headers["x-gamerid"] = json["row"]["gamerId"].ToString();
+
+            var settings = BackEnd.Backend.GetBackndChatSettings();
+            foreach (var header in settings)
+            {
+                headers[header.Key] = header.Value;
+            }
+
+            //headers["x-gamerid"] = "40a1f3f0-19a1-11f0-9ee9-c1c83fc196eb";
+
+            StartQueueProcessing();
+
+            initialized = true;
+
+            await BTask.CompletedTask;
+        }
+
+        private BTask<BackEnd.BackendReturnObject> GetUserInfoAsync()
+        {
+            var tcs = new BTaskCompletionSource<BackEnd.BackendReturnObject>();
+
+            BackEnd.Backend.BMember.GetUserInfoV2(result =>
+            {
+                tcs.SetResult(result);
+            });
+
+            return tcs.Task;
+        }
+
+        #region Queue Management
+
+        private void StartQueueProcessing()
+        {
+            if (isProcessingQueue) return;
+
+            isProcessingQueue = true;
+            ProcessQueue();
+        }
+
+        private async void ProcessQueue()
+        {
+            while (!queueCancellationSource.Token.IsCancellationRequested)
+            {
+                QueuedRequest request = null;
+
+                lock (queueLock)
+                {
+                    if (highPriorityQueue.Count > 0)
+                    {
+                        request = highPriorityQueue.Dequeue();
+                    }
+                    else if (requestQueue.Count > 0)
+                    {
+                        request = requestQueue.Dequeue();
+                    }
+                }
+
+                if (request != null)
+                {
+                    await ProcessRequest(request);
+
+                    if (requestDelay > 0)
+                    {
+                        await BTask.Delay(requestDelay);
+                    }
+                }
+                else
+                {
+                    await BTask.Yield();
+                }
+            }
+
+            isProcessingQueue = false;
+        }
+
+        private async BTask ProcessRequest(QueuedRequest queuedRequest)
+        {
+            try
+            {
+                var response = await DatabaseExecutor.Execute(queuedRequest.Request, headers, queuedRequest.CancellationToken);
+                queuedRequest.TaskCompletionSource.SetResult(response);
+            }
+            catch (Exception ex)
+            {
+                queuedRequest.TaskCompletionSource.SetException(ex);
+            }
+        }
+
+        private BTask<Response> EnqueueRequest(DatabaseRequest request, bool highPriority = false, CancellationToken cancellationToken = default)
+        {
+            if (!initialized)
+            {
+                throw new InvalidOperationException("[Database.Client] Client not initialized. Call Initialize() first.");
+            }
+
+            var queuedRequest = new QueuedRequest
+            {
+                Request = request,
+                TaskCompletionSource = new BTaskCompletionSource<Response>(),
+                CancellationToken = cancellationToken,
+                Timestamp = DateTime.Now
+            };
+
+            lock (queueLock)
+            {
+                if (highPriority)
+                {
+                    highPriorityQueue.Enqueue(queuedRequest);
+                }
+                else
+                {
+                    requestQueue.Enqueue(queuedRequest);
+                }
+            }
+
+            return queuedRequest.TaskCompletionSource.Task;
+        }
+
+        #endregion
+
+        #region Table Operations
+
+        public async BTask CreateTable<T>() where T : BaseModel, new()
+        {
+            var type = typeof(T);
+            if (createdTables.ContainsKey(type))
+            {
+                return;
+            }
+
+            var query = BuildCreateTableQuery<T>();
+
+            var request = new DatabaseRequest { Query = query };
+
+            var response = await EnqueueRequest(request, highPriority: true);
+
+            if (response.Success)
+            {
+                createdTables[type] = true;
+            }
+            else
+            {
+                throw new DatabaseException($"Failed to create table: {response.Error}");
+            }
+        }
+
+        public async BTask DropTable<T>() where T : BaseModel, new()
+        {
+            var type = typeof(T);
+            var instance = new T();
+            var query = $"DROP TABLE {instance.GetTableName()}";
+
+            var request = new DatabaseRequest { Query = query };
+
+            var response = await EnqueueRequest(request, highPriority: true);
+
+            if (response.Success)
+            {
+                createdTables.Remove(type);
+            }
+            else
+            {
+                throw new DatabaseException($"Failed to drop table: {response.Error}");
+            }
+        }
+
+        public async BTask AlterTable<T>(string alterStatement) where T : BaseModel, new()
+        {
+            var instance = new T();
+            var query = $"ALTER TABLE {instance.GetTableName()} {alterStatement}";
+
+            var request = new DatabaseRequest { Query = query };
+
+            var response = await EnqueueRequest(request, highPriority: true);
+
+            if (!response.Success)
+            {
+                throw new DatabaseException($"Failed to alter table: {response.Error}");
+            }
+        }
+
+        #endregion
+
+        #region Index Operations
+
+        public async BTask CreateIndex<T>(string indexName, params string[] columns) where T : BaseModel, new()
+        {
+            var instance = new T();
+            var query = $"CREATE INDEX {indexName} ON {instance.GetTableName()} ({string.Join(", ", columns)})";
+
+            var request = new DatabaseRequest { Query = query };
+
+            var response = await EnqueueRequest(request, highPriority: true);
+
+            if (!response.Success)
+            {
+                throw new DatabaseException($"Failed to create index: {response.Error}");
+            }
+        }
+
+        public async BTask DropIndex<T>(string indexName) where T : BaseModel, new()
+        {
+            var instance = new T();
+            var query = $"DROP INDEX {indexName} ON {instance.GetTableName()}";
+
+            var request = new DatabaseRequest { Query = query };
+
+            var response = await EnqueueRequest(request, highPriority: true);
+
+            if (!response.Success)
+            {
+                throw new DatabaseException($"Failed to drop index: {response.Error}");
+            }
+        }
+
+        #endregion
+
+        #region Query Operations
+
+        public QueryBuilder<T> From<T>() where T : BaseModel, new()
+        {
+            if (!initialized)
+            {
+                throw new InvalidOperationException("[Database.Client] Client not initialized. Call Initialize() first.");
+            }
+
+            return new QueryBuilder<T>(this);
+        }
+
+        public QueryBuilder<T> Query<T>() where T : BaseModel, new()
+        {
+            if (!initialized)
+            {
+                throw new InvalidOperationException("[Database.Client] Client not initialized. Call Initialize() first.");
+            }
+
+            return new QueryBuilder<T>(this);
+        }
+
+        public async BTask<Response> ExecuteRawQuery(string query, CancellationToken cancellationToken = default)
+        {
+            var request = new DatabaseRequest { Query = query };
+            return await EnqueueRequest(request, highPriority: false, cancellationToken);
+        }
+
+        internal async BTask<Response> ExecuteQuery(DatabaseRequest request, CancellationToken cancellationToken = default)
+        {
+            return await EnqueueRequest(request, highPriority: false, cancellationToken);
+        }
+
+        internal async BTask<Response> ExecuteMutation(DatabaseRequest request, CancellationToken cancellationToken = default)
+        {
+            return await EnqueueRequest(request, highPriority: true, cancellationToken);
+        }
+
+        /// <summary>
+        /// 트랜잭션 빌더 생성
+        /// </summary>
+        public TransactionBuilder Transaction()
+        {
+            if (!initialized)
+            {
+                throw new InvalidOperationException("[Database.Client] Client not initialized. Call Initialize() first.");
+            }
+
+            return new TransactionBuilder(this);
+        }
+
+        /// <summary>
+        /// 트랜잭션 실행 (내부용)
+        /// </summary>
+        internal async BTask<Response> ExecuteTransaction(DatabaseRequest request, CancellationToken cancellationToken = default)
+        {
+            return await EnqueueRequest(request, highPriority: true, cancellationToken);
+        }
+
+        #endregion
+
+        #region Cleanup
+
+        public void Dispose()
+        {
+            queueCancellationSource?.Cancel();
+            queueCancellationSource?.Dispose();
+
+            lock (queueLock)
+            {
+                requestQueue.Clear();
+                highPriorityQueue.Clear();
+            }
+
+            initialized = false;
+        }
+
+        #endregion
+
+        #region Query Generation Helper Methods
+
+        private string BuildCreateTableQuery<T>() where T : BaseModel, new()
+        {
+            var instance = new T();
+            var tableName = instance.GetTableName();
+            var columnList = instance.GetColumnList();
+
+            if (string.IsNullOrEmpty(tableName) || string.IsNullOrEmpty(columnList))
+            {
+                throw new InvalidOperationException($"Model class {typeof(T).Name} has not been processed by DatabaseWeaver. Table name or column information is missing.");
+            }
+
+            var sb = new StringBuilder();
+            sb.Append($"CREATE TABLE {tableName} (");
+
+            var columns = columnList.Split(',').Select(c => c.Trim()).ToArray();
+            var columnDefs = new List<string>();
+
+            foreach (var column in columns)
+            {
+                var dataType = instance.GetColumnDataType(column);
+                var nullable = instance.IsColumnNullable(column);
+                var defaultValue = instance.GetColumnDefaultValue(column);
+                var isPrimary = instance.GetPrimaryKeyColumnNames().Any(pk => pk.Equals(column, StringComparison.OrdinalIgnoreCase));
+
+                var columnDef = $"{column} {dataType}";
+
+                if (isPrimary)
+                {
+                    columnDef += " PRIMARY KEY";
+                    if (column.Equals(instance.GetAutoIncrementColumnName(), StringComparison.OrdinalIgnoreCase))
+                    {
+                        columnDef += " AUTO_INCREMENT";
+                    }
+                }
+                else if (!nullable)
+                {
+                    columnDef += " NOT NULL";
+                }
+
+                if (!string.IsNullOrEmpty(defaultValue) && !isPrimary)
+                {
+                    columnDef += $" DEFAULT {FormatDefaultValue(defaultValue, dataType)}";
+                }
+
+                columnDefs.Add(columnDef);
+            }
+
+            sb.Append(string.Join(", ", columnDefs));
+
+            var tableType = instance.GetTableType();
+            var tableTypeClause = tableType == TableType.UserTable ? "USERTABLE" : "FLEXIBLETABLE";
+            var readPermissions = string.Join(", ", instance.GetReadPermissions());
+            var writePermissions = string.Join(", ", instance.GetWritePermissions());
+
+            sb.Append($", {tableTypeClause} (");
+            sb.Append($"CLIENT_ACCESS = {instance.GetClientAccess().ToString().ToLower()}, ");
+            sb.Append($"READ = ({readPermissions}), ");
+            sb.Append($"WRITE = ({writePermissions})");
+            sb.Append("))");
+
+            return sb.ToString();
+        }
+
+        private static readonly HashSet<string> SqlFunctionsAndKeywords = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "NOW()", "CURRENT_TIMESTAMP", "CURRENT_TIMESTAMP()", "UUID()",
+            "CURRENT_DATE", "CURRENT_DATE()", "CURRENT_TIME", "CURRENT_TIME()",
+            "NULL"
+        };
+
+        private static string FormatDefaultValue(string defaultValue, string dataType)
+        {
+            if (string.IsNullOrWhiteSpace(defaultValue))
+                return defaultValue;
+
+            var trimmed = defaultValue.Trim();
+
+            // SQL 함수 및 키워드(NULL)는 그대로 반환
+            if (SqlFunctionsAndKeywords.Contains(trimmed))
+                return trimmed;
+
+            // 이미 따옴표로 감싸져 있으면 그대로 반환
+            if ((trimmed.StartsWith("'") && trimmed.EndsWith("'")) ||
+                (trimmed.StartsWith("\"") && trimmed.EndsWith("\"")))
+            {
+                return trimmed;
+            }
+
+            // 함수와 NULL을 제외한 모든 값은 따옴표로 감싸기
+            return $"'{trimmed.Replace("'", "''")}'";
+        }
+
+        #endregion
+    }
+
+    internal class QueuedRequest
+    {
+        public DatabaseRequest Request { get; set; }
+        public BTaskCompletionSource<Response> TaskCompletionSource { get; set; }
+        public CancellationToken CancellationToken { get; set; }
+        public DateTime Timestamp { get; set; }
+    }
+
+    public class BTaskCompletionSource<T>
+    {
+        private BTask<T> task;
+        private bool completed = false;
+        private readonly object lockObj = new object();
+
+        public BTaskCompletionSource()
+        {
+            task = new BTask<T>();
+        }
+
+        public BTask<T> Task => task;
+
+        public void SetResult(T result)
+        {
+            lock (lockObj)
+            {
+                if (completed) return;
+                completed = true;
+                task.SetResult(result);
+            }
+        }
+
+        public void SetException(Exception exception)
+        {
+            lock (lockObj)
+            {
+                if (completed) return;
+                completed = true;
+                task.SetException(exception);
+            }
+        }
+
+        public void SetCanceled()
+        {
+            SetException(new OperationCanceledException());
+        }
+    }
+}