@effectstream/db 0.100.0

package/src/sql/accounts.queries.ts

@@ -0,0 +1,350 @@
+/** Types generated for queries found in "src/sql/accounts.sql" */
+import { PreparedQuery } from '@pgtyped/runtime';
+
+/** 'NewAddress' parameters type */
+export interface INewAddressParams {
+  address: string;
+  address_type?: number | null | void;
+}
+
+/** 'NewAddress' return type */
+export type INewAddressResult = void;
+
+/** 'NewAddress' query type */
+export interface INewAddressQuery {
+  params: INewAddressParams;
+  result: INewAddressResult;
+}
+
+const newAddressIR: any = {"usedParamSet":{"address":true,"address_type":true},"params":[{"name":"address","required":true,"transform":{"type":"scalar"},"locs":[{"a":68,"b":76}]},{"name":"address_type","required":false,"transform":{"type":"scalar"},"locs":[{"a":79,"b":91}]}],"statement":"INSERT INTO effectstream.addresses (address, address_type) \nVALUES (:address!, :address_type)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.addresses (address, address_type) 
+ * VALUES (:address!, :address_type)
+ * ```
+ */
+export const newAddress = new PreparedQuery<INewAddressParams,INewAddressResult>(newAddressIR);
+
+
+/** 'NewAddressWithId' parameters type */
+export interface INewAddressWithIdParams {
+  account_id: number;
+  address: string;
+  address_type: number;
+}
+
+/** 'NewAddressWithId' return type */
+export type INewAddressWithIdResult = void;
+
+/** 'NewAddressWithId' query type */
+export interface INewAddressWithIdQuery {
+  params: INewAddressWithIdParams;
+  result: INewAddressWithIdResult;
+}
+
+const newAddressWithIdIR: any = {"usedParamSet":{"address":true,"address_type":true,"account_id":true},"params":[{"name":"address","required":true,"transform":{"type":"scalar"},"locs":[{"a":80,"b":88}]},{"name":"address_type","required":true,"transform":{"type":"scalar"},"locs":[{"a":91,"b":104}]},{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":107,"b":118}]}],"statement":"INSERT INTO effectstream.addresses (address, address_type, account_id) \nVALUES (:address!, :address_type!, :account_id!)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.addresses (address, address_type, account_id) 
+ * VALUES (:address!, :address_type!, :account_id!)
+ * ```
+ */
+export const newAddressWithId = new PreparedQuery<INewAddressWithIdParams,INewAddressWithIdResult>(newAddressWithIdIR);
+
+
+/** 'NewAccount' parameters type */
+export interface INewAccountParams {
+  primary_address?: string | null | void;
+}
+
+/** 'NewAccount' return type */
+export interface INewAccountResult {
+  id: number;
+}
+
+/** 'NewAccount' query type */
+export interface INewAccountQuery {
+  params: INewAccountParams;
+  result: INewAccountResult;
+}
+
+const newAccountIR: any = {"usedParamSet":{"primary_address":true},"params":[{"name":"primary_address","required":false,"transform":{"type":"scalar"},"locs":[{"a":61,"b":76}]}],"statement":"INSERT INTO effectstream.accounts (primary_address) \nVALUES (:primary_address)\nRETURNING id"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.accounts (primary_address) 
+ * VALUES (:primary_address)
+ * RETURNING id
+ * ```
+ */
+export const newAccount = new PreparedQuery<INewAccountParams,INewAccountResult>(newAccountIR);
+
+
+/** 'UpdateAddressAccount' parameters type */
+export interface IUpdateAddressAccountParams {
+  account_id: number;
+  address: string;
+}
+
+/** 'UpdateAddressAccount' return type */
+export type IUpdateAddressAccountResult = void;
+
+/** 'UpdateAddressAccount' query type */
+export interface IUpdateAddressAccountQuery {
+  params: IUpdateAddressAccountParams;
+  result: IUpdateAddressAccountResult;
+}
+
+const updateAddressAccountIR: any = {"usedParamSet":{"account_id":true,"address":true},"params":[{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":47,"b":58}]},{"name":"address","required":true,"transform":{"type":"scalar"},"locs":[{"a":76,"b":84}]}],"statement":"UPDATE effectstream.addresses\nSET account_id = :account_id!\nWHERE address = :address!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * UPDATE effectstream.addresses
+ * SET account_id = :account_id!
+ * WHERE address = :address!
+ * ```
+ */
+export const updateAddressAccount = new PreparedQuery<IUpdateAddressAccountParams,IUpdateAddressAccountResult>(updateAddressAccountIR);
+
+
+/** 'RemoveAddressAccount' parameters type */
+export interface IRemoveAddressAccountParams {
+  address: string;
+}
+
+/** 'RemoveAddressAccount' return type */
+export type IRemoveAddressAccountResult = void;
+
+/** 'RemoveAddressAccount' query type */
+export interface IRemoveAddressAccountQuery {
+  params: IRemoveAddressAccountParams;
+  result: IRemoveAddressAccountResult;
+}
+
+const removeAddressAccountIR: any = {"usedParamSet":{"address":true},"params":[{"name":"address","required":true,"transform":{"type":"scalar"},"locs":[{"a":68,"b":76}]}],"statement":"UPDATE effectstream.addresses\nSET account_id = NULL\nWHERE address = :address!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * UPDATE effectstream.addresses
+ * SET account_id = NULL
+ * WHERE address = :address!
+ * ```
+ */
+export const removeAddressAccount = new PreparedQuery<IRemoveAddressAccountParams,IRemoveAddressAccountResult>(removeAddressAccountIR);
+
+
+/** 'UpdatePrimaryAddress' parameters type */
+export interface IUpdatePrimaryAddressParams {
+  account_id: number;
+  primary_address?: string | null | void;
+}
+
+/** 'UpdatePrimaryAddress' return type */
+export type IUpdatePrimaryAddressResult = void;
+
+/** 'UpdatePrimaryAddress' query type */
+export interface IUpdatePrimaryAddressQuery {
+  params: IUpdatePrimaryAddressParams;
+  result: IUpdatePrimaryAddressResult;
+}
+
+const updatePrimaryAddressIR: any = {"usedParamSet":{"primary_address":true,"account_id":true},"params":[{"name":"primary_address","required":false,"transform":{"type":"scalar"},"locs":[{"a":51,"b":66}]},{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":79,"b":90}]}],"statement":"UPDATE effectstream.accounts\nSET primary_address = :primary_address\nWHERE id = :account_id!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * UPDATE effectstream.accounts
+ * SET primary_address = :primary_address
+ * WHERE id = :account_id!
+ * ```
+ */
+export const updatePrimaryAddress = new PreparedQuery<IUpdatePrimaryAddressParams,IUpdatePrimaryAddressResult>(updatePrimaryAddressIR);
+
+
+/** 'GetAddressByAddress' parameters type */
+export interface IGetAddressByAddressParams {
+  address: string;
+}
+
+/** 'GetAddressByAddress' return type */
+export interface IGetAddressByAddressResult {
+  account_id: number | null;
+  address: string;
+  address_type: number;
+}
+
+/** 'GetAddressByAddress' query type */
+export interface IGetAddressByAddressQuery {
+  params: IGetAddressByAddressParams;
+  result: IGetAddressByAddressResult;
+}
+
+const getAddressByAddressIR: any = {"usedParamSet":{"address":true},"params":[{"name":"address","required":true,"transform":{"type":"scalar"},"locs":[{"a":53,"b":61}]}],"statement":"SELECT * FROM effectstream.addresses\nWHERE address = :address!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.addresses
+ * WHERE address = :address!
+ * ```
+ */
+export const getAddressByAddress = new PreparedQuery<IGetAddressByAddressParams,IGetAddressByAddressResult>(getAddressByAddressIR);
+
+
+/** 'GetAddressByAccountId' parameters type */
+export interface IGetAddressByAccountIdParams {
+  account_id: number;
+}
+
+/** 'GetAddressByAccountId' return type */
+export interface IGetAddressByAccountIdResult {
+  account_id: number | null;
+  address: string;
+  address_type: number;
+}
+
+/** 'GetAddressByAccountId' query type */
+export interface IGetAddressByAccountIdQuery {
+  params: IGetAddressByAccountIdParams;
+  result: IGetAddressByAccountIdResult;
+}
+
+const getAddressByAccountIdIR: any = {"usedParamSet":{"account_id":true},"params":[{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":56,"b":67}]}],"statement":"SELECT * FROM effectstream.addresses\nWHERE account_id = :account_id!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.addresses
+ * WHERE account_id = :account_id!
+ * ```
+ */
+export const getAddressByAccountId = new PreparedQuery<IGetAddressByAccountIdParams,IGetAddressByAccountIdResult>(getAddressByAccountIdIR);
+
+
+/** 'GetAccountById' parameters type */
+export interface IGetAccountByIdParams {
+  account_id: number;
+}
+
+/** 'GetAccountById' return type */
+export interface IGetAccountByIdResult {
+  account_id: number | null;
+  address: string;
+  address_id: number;
+  address_type: number;
+  primary_address: string | null;
+}
+
+/** 'GetAccountById' query type */
+export interface IGetAccountByIdQuery {
+  params: IGetAccountByIdParams;
+  result: IGetAccountByIdResult;
+}
+
+const getAccountByIdIR: any = {"usedParamSet":{"account_id":true},"params":[{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":220,"b":231}]}],"statement":"SELECT account_id, address, address_type, primary_address, id as address_id FROM effectstream.accounts\nLEFT JOIN effectstream.addresses ON effectstream.accounts.primary_address =effectstream.addresses.address\nWHERE id = :account_id!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT account_id, address, address_type, primary_address, id as address_id FROM effectstream.accounts
+ * LEFT JOIN effectstream.addresses ON effectstream.accounts.primary_address =effectstream.addresses.address
+ * WHERE id = :account_id!
+ * ```
+ */
+export const getAccountById = new PreparedQuery<IGetAccountByIdParams,IGetAccountByIdResult>(getAccountByIdIR);
+
+
+/** 'GetAllAddresses' parameters type */
+export interface IGetAllAddressesParams {
+  after_account_id?: number | null | void;
+  after_address?: string | null | void;
+  limit?: number | null | void;
+}
+
+/** 'GetAllAddresses' return type */
+export interface IGetAllAddressesResult {
+  account_id: number | null;
+  address: string;
+  address_type: number;
+  primary_address: string | null;
+}
+
+/** 'GetAllAddresses' query type */
+export interface IGetAllAddressesQuery {
+  params: IGetAllAddressesParams;
+  result: IGetAllAddressesResult;
+}
+
+const getAllAddressesIR: any = {"usedParamSet":{"after_account_id":true,"after_address":true,"limit":true},"params":[{"name":"after_account_id","required":false,"transform":{"type":"scalar"},"locs":[{"a":401,"b":417},{"a":756,"b":772},{"a":817,"b":833},{"a":1143,"b":1159},{"a":1203,"b":1219}]},{"name":"after_address","required":false,"transform":{"type":"scalar"},"locs":[{"a":436,"b":449},{"a":1277,"b":1290}]},{"name":"limit","required":false,"transform":{"type":"scalar"},"locs":[{"a":1388,"b":1393}]}],"statement":"SELECT \n    addresses.address as \"address\", \n    addresses.address_type as \"address_type\",\n    addresses.account_id as \"account_id\",\n    accounts.primary_address as \"primary_address\"\nFROM effectstream.addresses\nLEFT JOIN effectstream.accounts ON effectstream.accounts.primary_address =effectstream.addresses.address\nWHERE\n    -- This clause is for the first page fetch when no cursor is provided\n    (:after_account_id::INT IS NULL AND :after_address::TEXT IS NULL)\n    OR\n    (\n        -- Case 1: The current row's account_id is \"greater\" than the cursor's.\n        -- This handles two sub-cases:\n        -- a) regular greater-than (e.g., 5 > 4)\n        -- b) current is NULL but cursor is NOT NULL (since NULLS sort LAST)\n        (addresses.account_id > :after_account_id::INT) OR (addresses.account_id IS NULL AND :after_account_id::INT IS NOT NULL)\n    )\n    OR\n    (\n        -- Case 2: The account_ids are equivalent, so we compare by the tie-breaker (address).\n        -- This handles two sub-cases for equivalence:\n        -- a) they are equal and not null (e.g., 5 = 5)\n        -- b) they are both null\n        (addresses.account_id = :after_account_id::INT OR (addresses.account_id IS NULL AND :after_account_id::INT IS NULL))\n        AND\n        (addresses.address > :after_address::TEXT)\n    )\nORDER BY addresses.account_id ASC NULLS LAST, addresses.address ASC\nLIMIT COALESCE(:limit, 1000)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT 
+ *     addresses.address as "address", 
+ *     addresses.address_type as "address_type",
+ *     addresses.account_id as "account_id",
+ *     accounts.primary_address as "primary_address"
+ * FROM effectstream.addresses
+ * LEFT JOIN effectstream.accounts ON effectstream.accounts.primary_address =effectstream.addresses.address
+ * WHERE
+ *     -- This clause is for the first page fetch when no cursor is provided
+ *     (:after_account_id::INT IS NULL AND :after_address::TEXT IS NULL)
+ *     OR
+ *     (
+ *         -- Case 1: The current row's account_id is "greater" than the cursor's.
+ *         -- This handles two sub-cases:
+ *         -- a) regular greater-than (e.g., 5 > 4)
+ *         -- b) current is NULL but cursor is NOT NULL (since NULLS sort LAST)
+ *         (addresses.account_id > :after_account_id::INT) OR (addresses.account_id IS NULL AND :after_account_id::INT IS NOT NULL)
+ *     )
+ *     OR
+ *     (
+ *         -- Case 2: The account_ids are equivalent, so we compare by the tie-breaker (address).
+ *         -- This handles two sub-cases for equivalence:
+ *         -- a) they are equal and not null (e.g., 5 = 5)
+ *         -- b) they are both null
+ *         (addresses.account_id = :after_account_id::INT OR (addresses.account_id IS NULL AND :after_account_id::INT IS NULL))
+ *         AND
+ *         (addresses.address > :after_address::TEXT)
+ *     )
+ * ORDER BY addresses.account_id ASC NULLS LAST, addresses.address ASC
+ * LIMIT COALESCE(:limit, 1000)
+ * ```
+ */
+export const getAllAddresses = new PreparedQuery<IGetAllAddressesParams,IGetAllAddressesResult>(getAllAddressesIR);
+
+
+/** 'GetAllAddressesCount' parameters type */
+export type IGetAllAddressesCountParams = void;
+
+/** 'GetAllAddressesCount' return type */
+export interface IGetAllAddressesCountResult {
+  total: string | null;
+}
+
+/** 'GetAllAddressesCount' query type */
+export interface IGetAllAddressesCountQuery {
+  params: IGetAllAddressesCountParams;
+  result: IGetAllAddressesCountResult;
+}
+
+const getAllAddressesCountIR: any = {"usedParamSet":{},"params":[],"statement":"SELECT COUNT(*) as total\nFROM effectstream.addresses"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT COUNT(*) as total
+ * FROM effectstream.addresses
+ * ```
+ */
+export const getAllAddressesCount = new PreparedQuery<IGetAllAddressesCountParams,IGetAllAddressesCountResult>(getAllAddressesCountIR);
+
+

package/src/sql/accounts.sql

@@ -0,0 +1,77 @@
+/* @name newAddress */
+INSERT INTO effectstream.addresses (address, address_type) 
+VALUES (:address!, :address_type);
+
+/* @name newAddressWithId */
+INSERT INTO effectstream.addresses (address, address_type, account_id) 
+VALUES (:address!, :address_type!, :account_id!); 
+
+/* @name newAccount */
+INSERT INTO effectstream.accounts (primary_address) 
+VALUES (:primary_address)
+RETURNING id;
+
+/* @name updateAddressAccount */
+UPDATE effectstream.addresses
+SET account_id = :account_id!
+WHERE address = :address!;
+
+/* @name removeAddressAccount */
+UPDATE effectstream.addresses
+SET account_id = NULL
+WHERE address = :address!;
+
+/* @name updatePrimaryAddress */
+UPDATE effectstream.accounts
+SET primary_address = :primary_address
+WHERE id = :account_id!;
+
+/* @name getAddressByAddress */
+SELECT * FROM effectstream.addresses
+WHERE address = :address!;
+
+/* @name getAddressByAccountId */
+SELECT * FROM effectstream.addresses
+WHERE account_id = :account_id!;
+
+/* @name getAccountById */
+SELECT account_id, address, address_type, primary_address, id as address_id FROM effectstream.accounts
+LEFT JOIN effectstream.addresses ON effectstream.accounts.primary_address =effectstream.addresses.address
+WHERE id = :account_id!;
+
+
+/* @name getAllAddresses */
+SELECT 
+    addresses.address as "address", 
+    addresses.address_type as "address_type",
+    addresses.account_id as "account_id",
+    accounts.primary_address as "primary_address"
+FROM effectstream.addresses
+LEFT JOIN effectstream.accounts ON effectstream.accounts.primary_address =effectstream.addresses.address
+WHERE
+    -- This clause is for the first page fetch when no cursor is provided
+    (:after_account_id::INT IS NULL AND :after_address::TEXT IS NULL)
+    OR
+    (
+        -- Case 1: The current row's account_id is "greater" than the cursor's.
+        -- This handles two sub-cases:
+        -- a) regular greater-than (e.g., 5 > 4)
+        -- b) current is NULL but cursor is NOT NULL (since NULLS sort LAST)
+        (addresses.account_id > :after_account_id::INT) OR (addresses.account_id IS NULL AND :after_account_id::INT IS NOT NULL)
+    )
+    OR
+    (
+        -- Case 2: The account_ids are equivalent, so we compare by the tie-breaker (address).
+        -- This handles two sub-cases for equivalence:
+        -- a) they are equal and not null (e.g., 5 = 5)
+        -- b) they are both null
+        (addresses.account_id = :after_account_id::INT OR (addresses.account_id IS NULL AND :after_account_id::INT IS NULL))
+        AND
+        (addresses.address > :after_address::TEXT)
+    )
+ORDER BY addresses.account_id ASC NULLS LAST, addresses.address ASC
+LIMIT COALESCE(:limit, 1000);
+
+/* @name getAllAddressesCount */
+SELECT COUNT(*) as total
+FROM effectstream.addresses;

package/src/sql/achievements.queries.ts

@@ -0,0 +1,74 @@
+/** Types generated for queries found in "src/sql/achievements.sql" */
+import { PreparedQuery } from '@pgtyped/runtime';
+
+export type DateOrString = Date | string;
+
+/** 'GetAchievementProgress' parameters type */
+export interface IGetAchievementProgressParams {
+  account_id: number;
+  names: readonly (string | null | void)[];
+}
+
+/** 'GetAchievementProgress' return type */
+export interface IGetAchievementProgressResult {
+  account_id: number;
+  completed_date: Date | null;
+  name: string;
+  progress: number | null;
+  total: number | null;
+}
+
+/** 'GetAchievementProgress' query type */
+export interface IGetAchievementProgressQuery {
+  params: IGetAchievementProgressParams;
+  result: IGetAchievementProgressResult;
+}
+
+const getAchievementProgressIR: any = {"usedParamSet":{"account_id":true,"names":true},"params":[{"name":"names","required":false,"transform":{"type":"array_spread"},"locs":[{"a":92,"b":97},{"a":110,"b":115}]},{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":67,"b":78}]}],"statement":"SELECT * FROM effectstream.achievement_progress\nWHERE account_id = :account_id!\nAND ('*' in :names OR name IN :names)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.achievement_progress
+ * WHERE account_id = :account_id!
+ * AND ('*' in :names OR name IN :names)
+ * ```
+ */
+export const getAchievementProgress = new PreparedQuery<IGetAchievementProgressParams,IGetAchievementProgressResult>(getAchievementProgressIR);
+
+
+/** 'SetAchievementProgress' parameters type */
+export interface ISetAchievementProgressParams {
+  account_id: number;
+  completed_date?: DateOrString | null | void;
+  name: string;
+  progress?: number | null | void;
+  total?: number | null | void;
+}
+
+/** 'SetAchievementProgress' return type */
+export type ISetAchievementProgressResult = void;
+
+/** 'SetAchievementProgress' query type */
+export interface ISetAchievementProgressQuery {
+  params: ISetAchievementProgressParams;
+  result: ISetAchievementProgressResult;
+}
+
+const setAchievementProgressIR: any = {"usedParamSet":{"account_id":true,"name":true,"completed_date":true,"progress":true,"total":true},"params":[{"name":"account_id","required":true,"transform":{"type":"scalar"},"locs":[{"a":106,"b":117}]},{"name":"name","required":true,"transform":{"type":"scalar"},"locs":[{"a":120,"b":125}]},{"name":"completed_date","required":false,"transform":{"type":"scalar"},"locs":[{"a":128,"b":142}]},{"name":"progress","required":false,"transform":{"type":"scalar"},"locs":[{"a":145,"b":153}]},{"name":"total","required":false,"transform":{"type":"scalar"},"locs":[{"a":156,"b":161}]}],"statement":"INSERT INTO effectstream.achievement_progress (account_id, name, completed_date, progress, total)\nVALUES (:account_id!, :name!, :completed_date, :progress, :total)\nON CONFLICT (account_id, name)\nDO UPDATE SET\n  completed_date = EXCLUDED.completed_date,\n  progress = EXCLUDED.progress,\n  total = EXCLUDED.total"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.achievement_progress (account_id, name, completed_date, progress, total)
+ * VALUES (:account_id!, :name!, :completed_date, :progress, :total)
+ * ON CONFLICT (account_id, name)
+ * DO UPDATE SET
+ *   completed_date = EXCLUDED.completed_date,
+ *   progress = EXCLUDED.progress,
+ *   total = EXCLUDED.total
+ * ```
+ */
+export const setAchievementProgress = new PreparedQuery<ISetAchievementProgressParams,ISetAchievementProgressResult>(setAchievementProgressIR);
+
+

package/src/sql/achievements.sql

@@ -0,0 +1,17 @@
+/*
+  @name getAchievementProgress
+  @param names -> (...)
+*/
+SELECT * FROM effectstream.achievement_progress
+WHERE account_id = :account_id!
+AND ('*' in :names OR name IN :names)
+;
+
+/* @name setAchievementProgress */
+INSERT INTO effectstream.achievement_progress (account_id, name, completed_date, progress, total)
+VALUES (:account_id!, :name!, :completed_date, :progress, :total)
+ON CONFLICT (account_id, name)
+DO UPDATE SET
+  completed_date = EXCLUDED.completed_date,
+  progress = EXCLUDED.progress,
+  total = EXCLUDED.total;