@jskit-ai/google-rewarded-core 0.1.1

package/src/shared/googleRewardedRuleResource.js

@@ -0,0 +1,136 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "google_rewarded_rules",
+  tableName: "google_rewarded_rules",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  gateKey: {
+    type: "string",
+    maxLength: 120,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  surface: {
+    type: "string",
+    maxLength: 64,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  enabled: {
+    type: "boolean",
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  unlockMinutes: {
+    type: "integer",
+    min: 0,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  cooldownMinutes: {
+    type: "integer",
+    min: 0,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  dailyLimit: {
+    type: "integer",
+    min: 0,
+    nullable: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  title: {
+    type: "string",
+    maxLength: 160,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  description: {
+    type: "string",
+    maxLength: 65535,
+    nullable: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  updatedAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["gateKey","surface","title","description"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/src/shared/googleRewardedUnlockReceiptResource.js

@@ -0,0 +1,113 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "google_rewarded_unlock_receipts",
+  tableName: "google_rewarded_unlock_receipts",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  userId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  gateKey: {
+    type: "string",
+    maxLength: 120,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  providerConfigId: {
+    type: "id",
+    nullable: true,
+    search: true,
+    relation: { kind: "lookup", namespace: "google-rewarded-provider-configs", valueKey: "id" },
+    belongsTo: "googleRewardedProviderConfigs",
+    as: "providerConfig",
+    ui: { formControl: "autocomplete" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  watchSessionId: {
+    type: "id",
+    nullable: true,
+    search: true,
+    relation: { kind: "lookup", namespace: "google-rewarded-watch-sessions", valueKey: "id" },
+    belongsTo: "googleRewardedWatchSessions",
+    as: "watchSession",
+    ui: { formControl: "autocomplete" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  grantedAt: {
+    type: "dateTime",
+    default: "now()",
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  unlockedUntil: {
+    type: "dateTime",
+    required: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["gateKey"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace_user",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/src/shared/googleRewardedWatchSessionResource.js

@@ -0,0 +1,139 @@
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const resource = defineCrudResource({
+  namespace: "google_rewarded_watch_sessions",
+  tableName: "google_rewarded_watch_sessions",
+  schema: {
+  workspaceId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  userId: {
+    type: "id",
+    required: true,
+    search: true,
+    hidden: true,
+    operations: {}
+  },
+  gateKey: {
+    type: "string",
+    maxLength: 120,
+    required: true,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: true },
+      patch: { required: false }
+    }
+  },
+  providerConfigId: {
+    type: "id",
+    nullable: true,
+    search: true,
+    relation: { kind: "lookup", namespace: "google-rewarded-provider-configs", valueKey: "id" },
+    belongsTo: "googleRewardedProviderConfigs",
+    as: "providerConfig",
+    ui: { formControl: "autocomplete" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  status: {
+    type: "string",
+    maxLength: 32,
+    search: true,
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  startedAt: {
+    type: "dateTime",
+    default: "now()",
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  rewardedAt: {
+    type: "dateTime",
+    nullable: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  completedAt: {
+    type: "dateTime",
+    nullable: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  closedAt: {
+    type: "dateTime",
+    nullable: true,
+    search: true,
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true },
+      create: { required: false },
+      patch: { required: false }
+    }
+  },
+  createdAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  updatedAt: {
+    type: "dateTime",
+    default: "now()",
+    storage: { writeSerializer: "datetime-utc" },
+    operations: {
+      output: { required: true }
+    }
+  },
+  },
+  searchSchema: {
+    id: { type: "id", actualField: "id" },
+    q: { type: "string", oneOf: ["gateKey","status"], filterOperator: "like", splitBy: " ", matchAll: true },
+  },
+  defaultSort: ["-createdAt"],
+  autofilter: "workspace_user",
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  contract: {
+    lookup: {
+      containerKey: "lookups",
+      defaultInclude: "*",
+      maxDepth: 3
+    }
+  }
+});
+
+export { resource };

package/src/shared/index.js

@@ -0,0 +1,12 @@
+export {
+  resource as googleRewardedRuleResource
+} from "./googleRewardedRuleResource.js";
+export {
+  resource as googleRewardedProviderConfigResource
+} from "./googleRewardedProviderConfigResource.js";
+export {
+  resource as googleRewardedWatchSessionResource
+} from "./googleRewardedWatchSessionResource.js";
+export {
+  resource as googleRewardedUnlockReceiptResource
+} from "./googleRewardedUnlockReceiptResource.js";

package/templates/migrations/google_rewarded_provider_configs_initial.cjs

@@ -0,0 +1,27 @@
+const TABLE_NAME = "google_rewarded_provider_configs";
+
+exports.up = async function up(knex) {
+  const hasCrudTable = await knex.schema.hasTable(TABLE_NAME);
+  if (hasCrudTable) {
+    return;
+  }
+
+  await knex.schema.createTable(TABLE_NAME, (table) => {
+    table.bigIncrements("id").unsigned().primary();
+    table.bigInteger("workspace_id").unsigned().notNullable();
+    table.string("surface", 64).notNullable();
+    table.boolean("enabled").notNullable().defaultTo(true);
+    table.string("ad_unit_path", 255).notNullable();
+    table.string("script_mode", 64).notNullable().defaultTo("gpt_rewarded");
+    table.timestamp("created_at").notNullable().defaultTo(knex.fn.now());
+    table.timestamp("updated_at").notNullable().defaultTo(knex.raw("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"));
+    table.index(["workspace_id"], "idx_google_rewarded_provider_configs_workspace");
+    table.unique(["workspace_id","surface"], "uq_google_rewarded_provider_configs_workspace_surface");
+    table.foreign(["workspace_id"], "fk_google_rewarded_provider_configs_workspace").references(["id"]).inTable("workspaces").onUpdate("RESTRICT").onDelete("CASCADE");
+  });
+
+};
+
+exports.down = async function down(knex) {
+  await knex.schema.dropTableIfExists(TABLE_NAME);
+};

package/templates/migrations/google_rewarded_rules_initial.cjs

@@ -0,0 +1,31 @@
+const TABLE_NAME = "google_rewarded_rules";
+
+exports.up = async function up(knex) {
+  const hasCrudTable = await knex.schema.hasTable(TABLE_NAME);
+  if (hasCrudTable) {
+    return;
+  }
+
+  await knex.schema.createTable(TABLE_NAME, (table) => {
+    table.bigIncrements("id").unsigned().primary();
+    table.bigInteger("workspace_id").unsigned().notNullable();
+    table.string("gate_key", 120).notNullable();
+    table.string("surface", 64).notNullable();
+    table.boolean("enabled").notNullable().defaultTo(true);
+    table.integer("unlock_minutes").unsigned().notNullable().defaultTo(30);
+    table.integer("cooldown_minutes").unsigned().notNullable().defaultTo(0);
+    table.integer("daily_limit").unsigned().nullable();
+    table.string("title", 160).notNullable().defaultTo("");
+    table.text("description").nullable();
+    table.timestamp("created_at").notNullable().defaultTo(knex.fn.now());
+    table.timestamp("updated_at").notNullable().defaultTo(knex.raw("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"));
+    table.index(["workspace_id"], "idx_google_rewarded_rules_workspace");
+    table.unique(["workspace_id","gate_key"], "uq_google_rewarded_rules_workspace_gate");
+    table.foreign(["workspace_id"], "fk_google_rewarded_rules_workspace").references(["id"]).inTable("workspaces").onUpdate("RESTRICT").onDelete("CASCADE");
+  });
+
+};
+
+exports.down = async function down(knex) {
+  await knex.schema.dropTableIfExists(TABLE_NAME);
+};

package/templates/migrations/google_rewarded_unlock_receipts_initial.cjs

@@ -0,0 +1,35 @@
+const TABLE_NAME = "google_rewarded_unlock_receipts";
+
+exports.up = async function up(knex) {
+  const hasCrudTable = await knex.schema.hasTable(TABLE_NAME);
+  if (hasCrudTable) {
+    return;
+  }
+
+  await knex.schema.createTable(TABLE_NAME, (table) => {
+    table.bigIncrements("id").unsigned().primary();
+    table.bigInteger("workspace_id").unsigned().notNullable();
+    table.bigInteger("user_id").unsigned().notNullable();
+    table.string("gate_key", 120).notNullable();
+    table.bigInteger("provider_config_id").unsigned().nullable();
+    table.bigInteger("watch_session_id").unsigned().nullable();
+    table.timestamp("granted_at").notNullable().defaultTo(knex.fn.now());
+    table.timestamp("unlocked_until").notNullable();
+    table.timestamp("created_at").notNullable().defaultTo(knex.fn.now());
+    table.index(["user_id"], "fk_google_rewarded_unlock_receipts_user");
+    table.index(["gate_key"], "idx_google_rewarded_unlock_receipts_gate");
+    table.index(["provider_config_id"], "idx_google_rewarded_unlock_receipts_provider_config");
+    table.index(["unlocked_until"], "idx_google_rewarded_unlock_receipts_unlocked_until");
+    table.index(["watch_session_id"], "idx_google_rewarded_unlock_receipts_watch_session");
+    table.index(["workspace_id","user_id"], "idx_google_rewarded_unlock_receipts_workspace_user");
+    table.foreign(["provider_config_id"], "fk_google_rewarded_unlock_receipts_provider_config").references(["id"]).inTable("google_rewarded_provider_configs").onUpdate("RESTRICT").onDelete("SET NULL");
+    table.foreign(["user_id"], "fk_google_rewarded_unlock_receipts_user").references(["id"]).inTable("users").onUpdate("RESTRICT").onDelete("CASCADE");
+    table.foreign(["watch_session_id"], "fk_google_rewarded_unlock_receipts_watch_session").references(["id"]).inTable("google_rewarded_watch_sessions").onUpdate("RESTRICT").onDelete("SET NULL");
+    table.foreign(["workspace_id"], "fk_google_rewarded_unlock_receipts_workspace").references(["id"]).inTable("workspaces").onUpdate("RESTRICT").onDelete("CASCADE");
+  });
+
+};
+
+exports.down = async function down(knex) {
+  await knex.schema.dropTableIfExists(TABLE_NAME);
+};

package/templates/migrations/google_rewarded_watch_sessions_initial.cjs

@@ -0,0 +1,36 @@
+const TABLE_NAME = "google_rewarded_watch_sessions";
+
+exports.up = async function up(knex) {
+  const hasCrudTable = await knex.schema.hasTable(TABLE_NAME);
+  if (hasCrudTable) {
+    return;
+  }
+
+  await knex.schema.createTable(TABLE_NAME, (table) => {
+    table.bigIncrements("id").unsigned().primary();
+    table.bigInteger("workspace_id").unsigned().notNullable();
+    table.bigInteger("user_id").unsigned().notNullable();
+    table.string("gate_key", 120).notNullable();
+    table.bigInteger("provider_config_id").unsigned().nullable();
+    table.string("status", 32).notNullable().defaultTo("started");
+    table.timestamp("started_at").notNullable().defaultTo(knex.fn.now());
+    table.timestamp("rewarded_at").nullable();
+    table.timestamp("completed_at").nullable();
+    table.timestamp("closed_at").nullable();
+    table.timestamp("created_at").notNullable().defaultTo(knex.fn.now());
+    table.timestamp("updated_at").notNullable().defaultTo(knex.raw("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"));
+    table.index(["user_id"], "fk_google_rewarded_watch_sessions_user");
+    table.index(["gate_key"], "idx_google_rewarded_watch_sessions_gate");
+    table.index(["provider_config_id"], "idx_google_rewarded_watch_sessions_provider_config");
+    table.index(["status"], "idx_google_rewarded_watch_sessions_status");
+    table.index(["workspace_id","user_id"], "idx_google_rewarded_watch_sessions_workspace_user");
+    table.foreign(["provider_config_id"], "fk_google_rewarded_watch_sessions_provider_config").references(["id"]).inTable("google_rewarded_provider_configs").onUpdate("RESTRICT").onDelete("SET NULL");
+    table.foreign(["user_id"], "fk_google_rewarded_watch_sessions_user").references(["id"]).inTable("users").onUpdate("RESTRICT").onDelete("CASCADE");
+    table.foreign(["workspace_id"], "fk_google_rewarded_watch_sessions_workspace").references(["id"]).inTable("workspaces").onUpdate("RESTRICT").onDelete("CASCADE");
+  });
+
+};
+
+exports.down = async function down(knex) {
+  await knex.schema.dropTableIfExists(TABLE_NAME);
+};